Jib ile container mimarisine alınmış bir Mikronaut uygulamasını Google Kubernetes Engine'e dağıtma

1. Genel Bakış

micronaut hakkında

Micronaut; modüler, kolayca test edilebilir mikro hizmetler ve sunucusuz uygulamalar oluşturmak için JVM tabanlı, tam yığınlı modern bir çerçevedir. Micronaut, minimum bellek ayak iziyle mükemmel başlatma süresi ve hızlı işleme hızı sunmayı amaçlar. Geliştiriciler Java, Groovy veya Kotlin'de Micronaut ile uygulama geliştirebilir.

Mikronaut şunları sağlar:

• Hızlı başlatma süresi ve Düşük bellek tüketimi: Yansıtma tabanlı IoC çerçeveleri, kodunuzdaki her alan, yöntem ve oluşturucu için yansıma verilerini yükler ve önbelleğe alırken, Micronaut'ta uygulamanızın başlatma süresi ve bellek tüketiminiz kod tabanınızın boyutuna bağlı değildir.
• Açıklayıcı, reaktif, derleme zamanına sahip HTTP istemcisi: Derleme zamanında uygulanan reaktif HTTP istemcilerini bildirimsel olarak derleyerek bellek tüketimini azaltır.
• Netty üzerine kurulmuş, engellemeyen HTTP sunucusu — Micronaut'un HTTP sunucusu, sorunsuz bir öğrenme eğrisiyle HTTP istemcileri tarafından kullanılabilecek API'lerin açığa çıkmasını mümkün olduğunca kolaylaştırır.
• Hızlı ve kolay test: Birim testlerinizde sunucuları ve istemcileri kolayca başlatın ve anında çalıştırın.
• Verimli derleme zamanı bağımlılık ekleme ve AOP: Micronaut, yansıma kullanmayan, derleme zamanına yönelik, en boy odaklı basit bir programlama API'si sağlar.
• Tamamen reaktif ve engellemeyen uygulamalar geliştirin - Micronaut, RxJava ve Reactor gibi Reaktif Akışları uygulayan her çerçeveyi destekler.

Daha fazla bilgi için lütfen Micronaut web sitesini ziyaret edin.

Kubernetes hakkında

Kubernetes, dizüstü bilgisayarlardan yüksek kullanılabilirliğe sahip çok düğümlü kümelere, herkese açık bulutlardan şirket içi dağıtımlara ve sanal makinelerden bare metal'e kadar birçok farklı ortamda çalışabilen açık kaynaklı bir projedir.

Bu laboratuvarda Kubernetes Engine'de çalışan Kubernetes'e Groovy tabanlı basit bir Mikronaut mikro hizmeti dağıtacaksınız.

Bu codelab'in amacı, mikro hizmetinizi Kubernetes'te çalışan çoğaltılmış bir hizmet olarak çalıştırmanızı sağlamaktır. Makinenizde geliştirdiğiniz kodu alıp Docker container görüntüsüne dönüştürür, ardından görüntüyü Kubernetes Engine'de çalıştırırsınız.

Parçaların nasıl bir araya geldiğini anlamanıza yardımcı olmak için bu codelab'deki çeşitli bölümlerin şemasını aşağıda bulabilirsiniz. Codelab'de ilerlerken bu belgeyi referans olarak kullanın. sonuna kadar tüm bunların anlamlı olması gerekir (ancak şu an için bunu göz ardı edebilirsiniz).

Bu codelab'de, Kubernetes Engine (Compute Engine'de çalışan Kubernetes'in Google tarafından barındırılan bir sürümü) gibi yönetilen bir ortam kullanarak temel altyapıyı kurmak yerine Kubernetes'i deneyimlemeye daha fazla odaklanabilirsiniz.

Kubernetes'i geliştirme dizüstü bilgisayarı gibi yerel makinenizde çalıştırmak istiyorsanız Minikube'yi incelemenizi öneririz. Bu özellik, geliştirme ve test amacıyla tek düğümlü Kubernetes kümesinin basit şekilde kurulumunu sunar. İsterseniz bu codelab'i tamamlamak için Minikube'yi kullanabilirsiniz.

Jeb hakkında

Jib, Java uygulamalarınız için Docker ve OCI görüntüleri oluşturmanıza olanak tanıyan açık kaynaklı bir araçtır. Maven ve Gradle eklentileri ve Java kitaplığı olarak kullanılabilir.

Jib'in hedefi:

• Hızlı: Değişikliklerinizi hızlı bir şekilde dağıtın. Jib, bağımlılıkları sınıflardan ayırarak uygulamanızı birden fazla katmana ayırır. Artık Docker'ın tüm Java uygulamanızı yeniden oluşturmasını beklemeniz gerekmez. Değişen katmanları dağıtmanız yeterlidir.
• Yeniden üretilebilir: Container görüntünüzü aynı içerikle yeniden oluşturduğunuzda her zaman aynı görüntü oluşturulur. Gereksiz güncellemeleri bir daha tetiklemeyin.
• Güncel: KSA bağımlılıklarınızı azaltın. Docker görüntünüzü Maven veya Gradle içinden derleyin ve istediğiniz kayıt defterine aktarın. Artık Dockerfile yazmaya ve Docker derleme/push'u çağırmaya gerek kalmaz.

Jib hakkında daha fazla bilgiyi GitHub proje sayfasında bulabilirsiniz.

Bu eğitim hakkında

Bu eğiticide, Java uygulamaları için container'lar derlemek amacıyla Jib aracından alınan örnek kod kullanılmaktadır.

Örnek, Micronaut çerçevesini ve Apache Groovy programlama dilini kullanan basit bir hello world hizmetidir.

Neler öğreneceksiniz?

• Basit bir Java uygulamasını Jib kullanarak Docker container'ı olarak paketleme
• Kubernetes Engine'de Kubernetes kümenizi oluşturma.
• Mikronaut hizmetinizi Kubernetes Engine'de Kubernetes'e dağıtma
• Hizmetinizin ölçeğini artırma ve yükseltmeyi kullanıma sunma
• Kubernetes Grafik kontrol paneline erişim.

Gerekenler

• Bir Google Cloud Platform Projesi
• Chrome veya Firefox gibi bir tarayıcı
• Vim, EMAC veya Nano gibi standart Linux metin düzenleyicileri hakkında bilgi

Bu eğiticiden nasıl yararlanacaksınız?

Yalnızca okuma Okuyun ve alıştırmaları tamamlayın

HTML/CSS web uygulamaları oluşturma deneyiminizi nasıl değerlendirirsiniz?

Acemi Orta Yeterli

Google Cloud Platform hizmetlerinin kullanımıyla ilgili deneyiminizi nasıl değerlendirirsiniz?

Acemi Orta Yeterli

2. Kurulum ve Gereksinimler

Kendi hızınızda ortam kurulumu

1. Cloud Console'da oturum açıp yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. (Gmail veya G Suite hesabınız yoksa hesap oluşturmanız gerekir.)

Not: Console.cloud.google.com olan URL'sini ezberleyerek Cloud Console'a kolayca erişebilirsiniz.

Tüm Google Cloud projelerinde benzersiz bir ad olan proje kimliğini unutmayın (yukarıdaki ad zaten alınmış ve size uygun olmayacaktır!). Bu kod laboratuvarın ilerleyen bölümlerinde PROJECT_ID olarak adlandırılacaktır.

Not: Gmail hesabı kullanıyorsanız varsayılan konumu Kuruluş yok olarak bırakabilirsiniz. G Suite hesabı kullanıyorsanız kuruluşunuz için uygun bir konum seçin.

2. Sonraki adımda, Google Cloud kaynaklarını kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir.

Bu codelab'i çalıştırmanın maliyeti, yüksek değildir. "Temizleme" bölümündeki talimatları izlediğinizden emin olun. bölümünde, bu eğiticinin dışında faturalandırmayla karşılaşmamanız için kaynakları nasıl kapatacağınız konusunda tavsiyelerde bulunuyoruz. Yeni Google Cloud kullanıcıları 300 ABD doları ücretsiz deneme programından yararlanabilir.

3. Micronaut örnek kaynak kodunu alma

Cloud Shell başlatıldıktan sonra komut satırını kullanarak ana dizindeki örnek kaynak kodunu klonlayabilir ve cd'yi örnek hizmetimizi içeren dizine ekleyebilirsiniz:

$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/

Jib proje deposu, başka örneklerle de oynamak isterseniz Spring Boot ya da Vert.x gibi diğer çerçeveler için de örnek projeler içerir.

4. Koda hızlı bir bakış

Basit Mikronaut hizmetimiz, kötü şöhretli Hello World mesajını veren bir denetleyiciden oluşur:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello World"
    }
}

HelloController denetleyicisi /hello yolu altındaki isteklere yanıt verir ve index() yöntemi HTTP GET isteklerini kabul eder.

Çıkışta doğru mesajın verilip verilmediğini kontrol etmek için bir Spock test sınıfı da kullanılabilir.

class HelloControllerSpec extends Specification {
    @Shared
    @AutoCleanup
    EmbeddedServer embeddedServer = ApplicationContext.run(EmbeddedServer)

    @Shared
    @AutoCleanup
    RxHttpClient client = embeddedServer.applicationContext.createBean(RxHttpClient, embeddedServer.getURL()) 

    void "test hello world response"() {
        when:
        HttpRequest request = HttpRequest.GET('/hello')
        String rsp  = client.toBlocking().retrieve(request)

        then:
        rsp == "Hello World"
    }
}

Basit bir birim testinden ibaret olan bu test, aslında üretimde çalıştırılan aynı Mikronaut sunucu yığınını (Netty çerçevesine dayalı olarak) çalıştırır. Bu nedenle, kodunuzun davranışı üründe testlerinizde olduğu gibi olacaktır.

Testleri çalıştırmak için aşağıdaki komutu çalıştırarak her şeyin yolunda olup olmadığını kontrol edebilirsiniz:

./gradlew test

5. Uygulamayı Yerel Olarak Çalıştırın

Aşağıdaki Gradle komutunu kullanarak Mikronaut hizmetini normal bir şekilde başlatabilirsiniz:

$ ./gradlew run

Uygulama başladıktan sonra küçük + simgesi sayesinde fazladan bir Cloud Shell örneği açabilir ve curl ile beklenen çıkışı alıp almadığınızı kontrol edebilirsiniz:

$ curl localhost:8080/hello

Basit bir "Hello World" ifadesini görebilirsiniz. mesajı görünür.

6. Uygulamayı Jib ile Docker container'ı olarak paketleme

Şimdi, uygulamanızı Kubernetes'te çalışmaya hazırlayın. Bu amaçla, Dockerfile cihazına kendimiz dokunmayacağımızdan, bizim için zor işleri yapmak üzere Jib'den yararlanacağız.

Container'ımızı derlemek için şu komutu çalıştıralım:

$ ./gradlew jibDockerBuild

Aşağıdaki çıkışı göreceksiniz:

Tagging image with generated image reference micronaut-jib:0.1. If you'd like to specify a different tag, you can set the jib.to.image parameter in your build.gradle, or use the --im
age=<MY IMAGE> commandline flag.

Containerizing application to Docker daemon as micronaut-jib:0.1...
warning: Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
Getting base image gcr.io/distroless/java...
Building dependencies layer...
Building resources layer...
Building classes layer...
Finalizing...

Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, example.micronaut.Application]
Loading to Docker daemon...

Built image to Docker daemon as micronaut-jib:0.1

Jib farklı katmanlarla bir Docker görüntüsü oluşturur: bağımlılıklarınız, kaynaklarınız ve derlenen kodunuz için. Dolayısıyla, örneğin kodunuzu değiştirirseniz, yalnızca derlenmiş sınıflarınızı içeren katman değiştirilir. Bu da, değiştirilmemiş önceki katmanların yeniden kullanılarak derleme zamanından tasarruf sağlar.

Görüntümüzü oluşturduğumuza göre Cloud Shell'in ilk sekmesinde Docker görüntümüzü çalıştırarak kullanıcı dostu hello mesajımızı görüp göremeyeceğimizi kontrol edelim:

$ docker run -it -p 8080:8080 micronaut-jib:0.1
16:57:20.255 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [cloud, gcp]
16:57:23.203 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 2926ms. Server Running: http://97b7d76ccf3f:8080

Hizmetimiz çalışıyor. Şimdi ikinci Cloud Shell sekmemizde curl komutumuzu başlatarak beklendiği gibi çalışıp çalışmadığını kontrol edebiliriz:

$ curl localhost:8080/hello
Hello World

Cloud Shell'de Ctrl+C tuşuna basarak container'ı durdurabilirsiniz.

7. Container mimarisine alınmış hizmetimizi kayıt defterine aktarma

Görüntünün beklendiği gibi çalıştığına göre artık görüntüyü Google Container Registry'ye aktarabilirsiniz. Google Container Registry, tüm Google Cloud projelerinden (ve Google Cloud Platform'un dışından) erişilebilen Docker görüntüleriniz için özel bir depo niteliğindedir.

Kayıt defterine aktarmadan önce, Araçlar > Container Registry'ye ekleyebilirsiniz. Etkinleştirilmemişse aşağıdaki iletişim kutusunu görürsünüz ve lütfen "Container Registry API'yi etkinleştir"i tıklayın. tıklayın:

Kayıt defteri hazır olduğunda görüntüyü kayıt defterine aktarmak için aşağıdaki komutları çalıştırın:

$ gcloud auth configure-docker
$ docker tag micronaut-jib:0.1 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Yukarıdaki komutlar, gcloud SDK'nın Docker'ı, görüntüleri Container Registry örneğinize aktarmak, görüntüyü kayıt defterindeki konumuna işaret edecek şekilde etiketlemek ve ardından kayıt defterine aktarmak üzere yapılandırmasına ve yetkilendirmesine olanak tanır.

Her şey yolunda giderse ve bir süre sonra kapsayıcı görüntüsünün konsolda listelendiğini görürsünüz: Araçlar > Container Registry'ye ekleyebilirsiniz. Bu noktada, Kubernetes'in erişip düzenleyebileceği ve birkaç dakika içinde göreceğiniz bir proje genelinde Docker görüntüsüne sahip olursunuz.

Burada kayıt defteri (gcr.io) için genel bir alan adı kullansak da hangi alt bölge ve paketin kullanılacağı konusunda daha fazla spesifik olabilirsiniz. Ayrıntılar şu adrestedir: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

8. Kümenizi oluşturma

Artık Kubernetes Engine kümenizi oluşturmaya hazırsınız. Ancak öncesinde web konsolunun Google Kubernetes Engine bölümüne gidin ve sistemin ilk kullanıma hazırlanmasını bekleyin (Bu işlem yalnızca birkaç saniye sürer).

Kümeler, Google tarafından yönetilen bir Kubernetes ana API sunucusu ve bir dizi çalışma düğümünden oluşur. Çalışma düğümleri Compute Engine sanal makineleridir. İki n1-standard-1 düğüme sahip bir küme oluşturmak için CloudShell oturumunuzdaki gcloud KSA'yı kullanalım (bu işlemin tamamlanması birkaç dakika sürebilir):

$ gcloud container clusters create hello-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Son adımda, kümenin oluşturulduğunu göreceksiniz.

Creating cluster hello-cluster in us-central1-c...done.
Created [https://container.googleapis.com/v1/projects/mn-gke-test/zones/us-central1-c/clusters/hello-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-c/hello-cluster?project=mn-gke-test
kubeconfig entry generated for hello-cluster.
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-c  1.9.7-gke.7     35.239.224.115  n1-standard-1  1.9.7-gke.7   2          RUNNING

Alternatif olarak bu kümeyi yukarıda gösterilen Console üzerinden de oluşturabilirsiniz: İşlem > Kubernetes Engine > Kapsayıcı Kümeleri > Kapsayıcı kümesi oluşturun.

Kümeyi başka bir Alt Bölgede oluşturabilirsiniz ancak container kayıt defteri tarafından kullanılan depolama paketiyle aynı bölgede tutmanız önerilir (önceki adıma bakın).

Artık Google Kubernetes Engine tarafından desteklenen, tam işlevli bir Kubernetes kümenizin olması gerekir:

Kendi container mimarisine alınmış uygulamanızı Kubernetes kümesine dağıtmanın zamanı geldi. Artık kubectl komut satırını (zaten Cloud Shell ortamınızda oluşturulmuş) kullanacaksınız. Bu codelab'in geri kalanı için hem Kubernetes istemcisinin hem sunucu sürümünün 1.2 veya üzeri olması gerekir. kubectl version, komutun mevcut sürümünü gösterir.

9. Uygulamanızı Kubernetes'e dağıtma

Kubernetes dağıtımı, az önce oluşturduğunuz container görüntüsünü kullanarak uygulamanızın birden fazla örneğini oluşturabilir, yönetebilir ve ölçeklendirebilir. kubectl create deployment komutunu kullanarak uygulamanızın Kubernetes'te dağıtımını oluşturalım:

$ kubectl create deployment hello-micronaut \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Oluşturduğunuz dağıtımı görüntülemek için şu komutu çalıştırmanız yeterlidir:

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   1         1         1            1           5m

Dağıtım tarafından oluşturulan uygulama örneklerini görüntülemek için şu komutu çalıştırın:

$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
hello-micronaut-5647fb98c5-lh5h7   1/1       Running   0          5m

Bu noktada, container'ınızı Kubernetes kontrolü altında çalıştırmakla birlikte dış dünyanın erişimine de açmanız gerekir.

10. Harici trafiğe izin ver

Varsayılan olarak kapsüle yalnızca küme içindeki dahili IP'si ile erişilebilir. hello-micronaut container'ına Kubernetes sanal ağının dışından erişilebilmesini sağlamak için kapsülü Kubernetes hizmeti olarak kullanıma sunmanız gerekir.

Cloud Shell'den kubectl expose komutunu --type=LoadBalancer işaretiyle birlikte kullanarak kapsülü herkese açık internette kullanıma sunabilirsiniz. Bu işaret, harici olarak erişilebilir bir IP oluşturmak için gereklidir :

$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080

Bu komutta kullanılan işaret, temel altyapı (bu örnekte Compute Engine Yük Dengeleyici) tarafından sağlanan yük dengeleyiciyi kullanacağınızı belirtir. Kapsülü doğrudan değil, dağıtımı kullanıma sunduğunuzu unutmayın. Bu durum, sonuçta elde edilen hizmetin, dağıtım tarafından yönetilen tüm kapsüllerde trafik yükünü dengelemesine neden olur (Bu durumda yalnızca 1 kapsül olur ancak daha sonra daha fazla replika eklemeniz gerekir).

Ana Kubernetes, hizmeti Google Cloud Platform dışından tamamen erişilebilir hale getirmek için yük dengeleyiciyi ve ilgili Compute Engine iletim kurallarını, hedef havuzları ve güvenlik duvarı kurallarını oluşturur.

Hizmetin herkesin erişebileceği IP adresini bulmak için kubectl sağlayıcısından tüm küme hizmetlerinin listelenmesini isteyin:

$ kubectl get services
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-micronaut   LoadBalancer   10.39.243.251   aaa.bbb.ccc.ddd 8080:30354/TCP   1m
kubernetes        ClusterIP      10.39.240.1     <none>          443/TCP          31m

EXTERNAL-IP öğesinin kullanılabilir ve görünür hale gelmesi birkaç dakika sürebilir. EXTERNAL-IP eksikse birkaç dakika bekleyip tekrar deneyin.

Hizmetiniz için listelenen ve her ikisi de 8080 bağlantı noktası olmak üzere 2 IP adresi bulunduğunu unutmayın. Bunlardan biri, yalnızca bulut sanal ağınızda görünen dahili IP'dir. diğeri ise harici yük dengeli IP'dir. Bu örnekte, harici IP adresi aaa.bbb.ccc.ddd şeklindedir.

Artık tarayıcınızı şu adrese yönlendirerek hizmete ulaşabileceksiniz: http://<EXTERNAL_IP>:8080/hello

11. Hizmetinizin ölçeğini artırın

Kubernetes'in sunduğu güçlü özelliklerden biri de uygulamanızı ölçeklendirmenin kolay olmasıdır. Uygulamanız için aniden daha fazla kapasiteye ihtiyaç duyduğunuzu varsayalım. replika denetleyicisine uygulama örnekleriniz için yeni sayıda replika yönetmesini söyleyebilirsiniz:

$ kubectl scale deployment hello-micronaut --replicas=3
deployment.extensions "hello-micronaut" scaled

$ kubectl get deployment
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   3         3         3            3           16m

Buradaki bildirim temelli yaklaşımı göz önünde bulundurun. Yeni örnekleri başlatmak veya durdurmak yerine, her zaman kaç örneğin çalışması gerektiğini siz bildirirsiniz. Kubernetes mutabakat döngüleri, yalnızca gerçeğin istediğinizle eşleştiğinden emin olur ve gerekirse işlem yapar.

12. Hizmetinizde yükseltmeyi kullanıma sunma

Bir noktada, üretime dağıttığınız uygulama için hata düzeltmeleri veya ek özellikler gerekecek. Kubernetes, kullanıcılarınızı etkilemeden yeni bir sürümü üretime dağıtmanıza yardımcı olur.

İlk olarak uygulamayı değiştirelim. Cloud Shell'den kod düzenleyiciyi açın.

/jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy sayfasına gidin ve yanıtın değerini güncelleyin:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello Kubernetes World"
    }
}

/jib/examples/micronaut/build.gradle ayında, aşağıdaki satırı güncelleyerek resmimizin 0.1 olan sürümünü 0.2'ye yükselteceğiz:

version '0.2'

Ardından uygulamayı yeniden derleyip en son değişikliklerle paketleyin:

$ ./gradlew jibDockerBuild

Ardından görüntüyü etiketleyip container görüntüsü kayıt defterine aktarın:

$ docker tag micronaut-jib:0.2 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

Önbelleğe alma özelliğinden tam olarak yararlandığımız için bu güncellenmiş görüntüyü oluşturup aktarmak çok daha hızlı olacaktır.

Artık Kubernetes'i kullanarak çoğaltma denetleyicinizi uygulamanın yeni sürümüne sorunsuzca güncelleyebilirsiniz. Çalışan kapsayıcınızın görüntü etiketini değiştirmek için mevcut hello-micronaut deployment öğesini düzenlemeniz ve gcr.io/PROJECT_ID/micronaut-jib:0.1 olan görüntüyü gcr.io/PROJECT_ID/micronaut-jib:0.2 olarak değiştirmeniz gerekir.

kubectl set image komutunu kullanarak Kubernetes'ten uygulamanızın yeni sürümünü periyodik güncelleme ile kümenin tamamına tek seferde dağıtmasını isteyebilirsiniz:

$ kubectl set image deployment/hello-micronaut \
          micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

deployment.apps "hello-micronaut" image updated

Bu durum yaşanırken hizmetlerin kullanıcıları hizmet kesintisiyle karşılaşabilir. Ancak bunun nedeni, yapılandırılmış bir durum denetimi olmamasıdır. Bu biraz daha gelişmiş bir yapılandırmadır; bu laboratuvarda durum denetimi eklemeyeceğiz.

Yeni yanıtı döndürüp döndürmediğini görmek için http://EXTERNAL_IP:8080 adresini tekrar kontrol edin.

13. Sürümü geri döndür

Hata, uygulamanın yeni sürümünde bir hata mı yaptınız? Belki de yeni sürümde bir hata vardır ve hızlıca geri almanız gerekmiştir. Kubernetes sayesinde önceki duruma kolayca geri dönebilirsiniz. Aşağıdaki komutu çalıştırarak uygulamayı geri alalım:

$ kubectl rollout undo deployment/hello-micronaut

Hizmetin çıkışına göz atarsanız ilk "Hello World"ü mesajını alırsınız.

14. Özet

Bu adımda Apache Groovy tabanlı basit bir Micronaut hello World hizmeti oluşturdunuz ve bu hizmeti doğrudan Cloud Shell'den çalıştırdınız, Jib ile container olarak paketledi ve Google Kubernetes Engine'e dağıttınız.

15. Tebrikler!

Yeni bir Apache Groovy / Micronaut web tabanlı mikro hizmeti derlemeyi ve Google Kubernetes Engine'de Kubernetes'e dağıtmayı öğrendiniz.

Daha Fazla Bilgi

• Jib belgeleri ve örnekleri: https://github.com/GoogleContainerTools/jib/
• Mikronaut web sitesi: http://micronaut.io/
• Google Cloud Platform'da Java: https://cloud.google.com/java/
• Java örnekleri için: https://cloud.google.com/java/samples
• Daha uzun ve eksiksiz bir Kubernetes eğiticisi için full-stack bir uygulamayı dağıtmanın adımlarını içeren bit.ly/k8s-lab adresini ziyaret edin.

Lisans

Bu çalışma, Creative Commons Attribution 2.0 Genel Amaçlı Lisans ile lisans altına alınmıştır.