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 kullanılan modern, JVM tabanlı, tam yığınlı bir çerçevedir. Micronaut, minimum bellekte kaplanan yer ile hızlı işleme hızı ve kısa başlatma süresi sunmayı amaçlar. Geliştiriciler, Java, Groovy veya Kotlin'de Micronaut ile geliştirebilir.

Micronaut'un sağladıkları:

• Hızlı başlangıç süresi ve düşük bellek tüketimi: Yansımaya dayalı IoC çerçeveleri, kodunuzdaki her alan, yöntem ve oluşturucu için yansıma verilerini yükleyip önbelleğe alırken Micronaut'ta uygulamanızın başlangıç süresi ve bellek tüketimi, kod tabanınızın boyutuyla sınırlı değildir.
• Bildirimsel, tepkisel, derleme zamanı HTTP istemcisi: Derleme zamanında uygulanan ve bellek tüketimini azaltan tepkisel HTTP istemcilerini bildirimsel olarak oluşturun.
• Netty üzerine kurulu, engellemeyen HTTP sunucusu: Micronaut'un HTTP sunucusu, kolay öğrenme eğrisiyle HTTP istemcileri tarafından kullanılabilen API'leri mümkün olduğunca kolay bir şekilde kullanıma sunar.
• Hızlı ve kolay test: Birim testlerinizde sunucuları ve istemcileri kolayca başlatıp anında çalıştırın.
• Derleme zamanında verimli bağımlılık ekleme ve AOP: Micronaut, yansıtma kullanmayan basit bir derleme zamanı yönelimli programlama API'si sağlar.
• Tamamen tepkisel ve engellemeyen uygulamalar oluşturun: Micronaut, RxJava ve Reactor dahil olmak üzere Reactive Streams'i uygulayan tüm çerçeveleri destekler.

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

Kubernetes hakkında

Kubernetes; dizüstü bilgisayarlardan yüksek kullanılabilirlik sağlayan çok düğümlü kümelere, herkese açık bulutlardan şirket içi dağıtımlara, sanal makinelerden çıplak metal sunuculara kadar birçok farklı ortamda çalışabilen açık kaynaklı bir projedir.

Bu laboratuvarda, Kubernetes Engine'de çalışan Kubernetes'e basit bir Groovy tabanlı Micronaut mikro hizmeti dağıtıyorsunuz.

Bu codelab'in amacı, mikro hizmetinizi Kubernetes üzerinde çalışan bir çoğaltılmış 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 ve bu görüntüyü Kubernetes Engine'de çalıştırırsınız.

Bu codelab'de kullanılan çeşitli parçaların nasıl bir araya geldiğini anlamanıza yardımcı olacak bir diyagram aşağıda verilmiştir. Bu bilgiyi, codelab'de ilerlerken referans olarak kullanın. Sonuna geldiğinizde her şey anlaşılır olacaktır (ancak şimdilik bu bilgiyi göz ardı edebilirsiniz).

Bu codelab'in amacı doğrultusunda, Kubernetes Engine (Compute Engine'de çalışan, Google tarafından barındırılan bir Kubernetes sürümü) gibi yönetilen bir ortam kullanmak, temel altyapıyı ayarlamak yerine Kubernetes'i deneyimlemeye daha fazla odaklanmanızı sağlar.

Kubernetes'i yerel makinenizde (ör. geliştirme dizüstü bilgisayarı) çalıştırmak istiyorsanız Minikube'u incelemeniz önerilir. Bu, geliştirme ve test amaçları için tek düğümlü bir Kubernetes kümesinin basit bir şekilde kurulmasını sağlar. İsterseniz bu codelab'i incelemek için Minikube'u kullanabilirsiniz.

Jib hakkında

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

Jib'in amacı:

• Hızlı: Değişikliklerinizi hızlıca dağıtın. Jib, uygulamanızı birden fazla katmana ayırır ve bağımlılıkları sınıflardan ayırır. Artık Docker'ın tüm Java uygulamanızı yeniden oluşturmasını beklemeniz gerekmiyor. Yalnızca değişen katmanları dağıtmanız yeterli.
• Yeniden üretilebilir: Container görüntünüzü aynı içeriklerle yeniden oluşturduğunuzda her zaman aynı görüntü oluşturulur. Bir daha asla gereksiz bir güncellemeyi tetiklemeyin.
• Daemonless: KSA bağımlılıklarınızı azaltın. Docker görüntünüzü Maven veya Gradle'da oluşturup istediğiniz kayıt defterine gönderin. Artık Dockerfile yazmanıza ve docker build/push komutunu çağırmanıza gerek yok.

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

Bu eğitici hakkında

Bu eğitimde, Java uygulamaları için kapsayıcılar oluşturmak üzere Jib aracındaki örnek kod kullanılır.

Örnek, Micronaut çerçevesi ve Apache Groovy programlama dili kullanılarak oluşturulmuş basit bir hello world hizmetidir.

Neler öğreneceksiniz?

• Jib kullanarak basit bir Java uygulamasını Docker container'ı olarak paketleme
• Kubernetes Engine'de Kubernetes kümenizi oluşturma
• Micronaut hizmetinizi Kubernetes Engine'deki Kubernetes'e dağıtma
• Hizmetinizi nasıl ölçeklendireceğinizi ve yükseltme dağıtacağınızı öğrenin.
• Kubernetes grafik kontrol paneline erişme

Gerekenler

• Google Cloud Platform projesi
• Chrome veya Firefox gibi bir tarayıcı
• Vim, EMACs veya Nano gibi standart Linux metin düzenleyicileri hakkında bilgi sahibi olmanız gerekir.

Bu eğitimi nasıl kullanacaksınız?

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

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

Yeni başlayan Orta düzey Uzman

Google Cloud Platform hizmetlerini kullanma deneyiminizi nasıl değerlendirirsiniz?

Başlangıç Orta İleri

2. Kurulum ve Gereksinimler

Yönlendirmesiz ortam kurulumu

1. Cloud Console'da oturum açın ve 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: URL'sini (console.cloud.google.com) ezberleyerek Cloud Console'a kolayca erişebilirsiniz.

Proje kimliğini unutmayın. Bu kimlik, tüm Google Cloud projelerinde benzersiz bir addır (Yukarıdaki ad zaten alınmış olduğundan sizin için çalışmayacaktır). Bu codelab'in ilerleyen kısımlarında 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. Ardından, Google Cloud kaynaklarını kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir.

Bu codelab'i tamamlamak neredeyse hiç maliyetli değildir. Bu eğitimin ötesinde faturalandırma ücreti alınmaması için kaynakları nasıl kapatacağınız konusunda size tavsiyelerde bulunan "Temizleme" bölümündeki talimatları uyguladığınızdan emin olun. Google Cloud'un yeni kullanıcıları 300 ABD doları değerinde ü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 kodu klonlayabilir ve örnek hizmetimizi içeren dizine gidebilirsiniz:

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

Jib proje deposunda, diğer örneklerle de oynamak isterseniz Spring Boot veya Vert.x gibi diğer çerçeveler için örnek projeler de bulunur.

4. Koda hızlı bir bakış

Basit Micronaut hizmetimiz, meşhur "Hello World" mesajını veren bir denetleyiciden oluşur:

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

HelloController denetleyicisi, /hello yolundaki isteklere yanıt veriyor ve index() yöntemi, HTTP GET isteklerini kabul ediyor.

Çıkışta doğru mesajın verildiğini kontrol etmek için 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"
    }
}

Bu test, basit bir birim testinden daha fazlasını yapar ve üretimde çalıştırılan aynı Micronaut sunucu yığınını (Netty çerçevesine dayalı) gerçekten çalıştırır. Bu nedenle, kodunuzun davranışı ürün ve testlerinizde aynı olur.

Testleri çalıştırmak için aşağıdaki komutu çalıştırarak her şeyin yolunda olduğunu görebilirsiniz:

./gradlew test

5. Uygulamayı Yerel Olarak Çalıştırma

Micronaut hizmetini aşağıdaki Gradle komutuyla normal şekilde başlatabilirsiniz:

$ ./gradlew run

Uygulama başladıktan sonra küçük + simgesi sayesinde ek bir Cloud Shell örneği açabilir ve ardından curl ile beklenen çıktıyı aldığınızı kontrol edebilirsiniz:

$ curl localhost:8080/hello

Basit bir "Hello World" mesajının göründüğünü görmelisiniz.

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

Ardından, uygulamanızı Kubernetes'te çalışmaya hazırlayın. Bu amaçla, Dockerfile ile kendimiz uğraşmak zorunda kalmayacağımız için zorlu işleri bizim için yapması amacıyla Jib'den yararlanacağız.

Kapsayıcımızı oluşturmak için komutu çalıştıralım:

$ ./gradlew jibDockerBuild

Görmeniz gereken çıkış şudur:

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, bağımlılıklarınız, kaynaklarınız ve derlenmiş kodunuz için farklı katmanlara sahip bir Docker görüntüsü oluşturur. Örneğin, kodunuzu değiştirirseniz yalnızca derlenmiş sınıflarınızın bulunduğu katman değiştirilir. Böylece, dokunulmamış önceki katmanlar yeniden kullanılarak derleme süresinden tasarruf edilir.

Görüntümüz oluşturulduğuna göre, Docker görüntümüzü Cloud Shell'in ilk sekmesinde çalıştırarak dostça merhaba mesajımızı görüp göremediğ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 çalıştırarak beklendiği gibi çalışıp çalışmadığını kontrol edebiliriz:

$ curl localhost:8080/hello
Hello World

Cloud Shell'de Ctrl+C tuşuna basarak kapsayıcıyı durdurabilirsiniz.

7. Kapsayıcıya alınmış hizmetimizi kayıt defterine gönderme

Artık görüntü istediğiniz gibi çalıştığına göre, her Google Cloud projesinden (ancak Google Cloud Platform'un dışından da) erişilebilen Docker görüntüleriniz için özel bir depo olan Google Container Registry'ye aktarabilirsiniz.

Kayıt defterine göndermeden önce Araçlar > Container Registry'ye giderek Container Registry'nin projemiz için etkinleştirildiğinden emin olalım. Etkinleştirilmemişse aşağıdaki iletişim kutusunu görürsünüz. Etkinleştirmek için lütfen "Container Registry API'yi etkinleştir"i tıklayın:

Kayıt hazır olduğunda görüntüyü kayda göndermek 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'ı yapılandırıp Container Registry örneğinize görüntü aktarması, görüntüyü kayıt defterindeki konumuna işaret edecek şekilde etiketlemesi ve ardından kayıt defterine aktarması için yetkilendirmesine olanak tanır.

Her şey yolunda giderse kısa bir süre sonra Araçlar > Container Registry bölümünde kapsayıcı resminin listelendiğini görebilirsiniz. Bu noktada, Kubernetes'in erişebileceği ve birkaç dakika içinde göreceğiniz gibi düzenleyebileceği proje genelinde bir Docker görüntüsüne sahip olursunuz.

Burada kayıt için genel bir alan (gcr.io) kullandığımızı ancak hangi bölge ve paketin kullanılacağı konusunda daha spesifik olabileceğinizi unutmayın. Ayrıntılar şu belgede açıklanmıştır: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

8. Kümenizi oluşturma

Tamam, 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 başlatılmasını bekleyin (yalnızca birkaç saniye sürer).

Küme, Google tarafından yönetilen bir Kubernetes ana API sunucusundan ve bir dizi çalışma düğümünden oluşur. Çalışan düğümleri, Compute Engine sanal makineleridir. İki n1-standard-1 düğümlü bir küme oluşturmak için Cloud Shell 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

Sonunda, kümenin oluşturulduğunu görürsünüz.

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, yukarıda gösterilen Konsol üzerinden de bu kümeyi oluşturabilirsiniz: Compute > Kubernetes Engine > Container Clusters > Create a container cluster.

Küme başka bir bölgede oluşturulabilir ancak kapsayıcı kayıt defteri tarafından kullanılan depolama paketiyle aynı bölgede tutulması önerilir (önceki adıma bakın).

Artık Google Kubernetes Engine tarafından desteklenen, tam işlevli bir Kubernetes kümeniz olmalıdır:

Şimdi kendi container mimarisine alınmış uygulamanızı Kubernetes kümesine dağıtma zamanı. Bundan sonra kubectl komut satırını (Cloud Shell ortamınızda zaten ayarlanmış) kullanacaksınız. Bu codelab'in geri kalanında hem Kubernetes istemci hem de 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ı, yeni oluşturduğunuz kapsayıcı 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'e dağıtımını oluşturalım:

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

Yeni oluşturduğunuz dağıtımı görüntülemek için şu komutu çalıştırın:

$ 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, kapsayıcınız Kubernetes'in kontrolü altında çalışıyor olmalıdır ancak yine de dış dünyaya erişilebilir hale getirmeniz gerekir.

10. Harici trafiğe izin ver

Pod'a varsayılan olarak yalnızca küme içindeki dahili IP'si üzerinden erişilebilir. hello-micronaut kapsayıcısına Kubernetes sanal ağının dışından erişilebilmesi için pod'u Kubernetes hizmeti olarak kullanıma sunmanız gerekir.

Cloud Shell'den, kubectl expose komutunu --type=LoadBalancer işaretiyle birlikte kullanarak pod'u herkese açık internete sunabilirsiniz. Bu işaret, harici olarak erişilebilen bir IP oluşturmak için gereklidir :

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

Bu komutta kullanılan işaret, temel altyapı tarafından sağlanan yük dengeleyiciyi (bu örnekte Compute Engine yük dengeleyici) kullanacağınızı belirtir. Doğrudan pod'u değil, dağıtımı kullanıma sunduğunuzu unutmayın. Bu işlem, sonuçtaki hizmetin trafiği dağıtım tarafından yönetilen tüm pod'lar arasında yük dengelemesine neden olur (bu durumda yalnızca 1 pod vardır ancak daha sonra daha fazla kopya ekleyeceksiniz).

Kubernetes ana makinesi, hizmetin Google Cloud Platform dışından tam olarak erişilebilir olması için yük dengeleyiciyi ve ilgili Compute Engine yönlendirme kurallarını, hedef havuzlarını ve güvenlik duvarı kurallarını oluşturur.

Hizmetin herkese açık IP adresini bulmak için kubectl ile 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 hâle gelmesi birkaç dakika sürebilir. EXTERNAL-IP simgesi görünmüyorsa birkaç dakika bekleyip tekrar deneyin.

Hizmetiniz için 2 IP adresinin listelendiğini ve her ikisinin de 8080 bağlantı noktasına hizmet verdiğini unutmayın. Biri yalnızca bulut sanal ağınızda görünen dahili IP, diğeri ise harici yük dengeli IP'dir. Bu örnekte, harici IP adresi aaa.bbb.ccc.ddd'dır.

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

11. Hizmetinizi ölçeklendirme

Kubernetes'in sunduğu güçlü özelliklerden biri, uygulamanızı ölçeklendirmenin ne kadar kolay olduğudur. Uygulamanız için aniden daha fazla kapasiteye ihtiyacınız olduğunu varsayalım. Bu durumda, Replication Controller'a uygulama örnekleriniz için yeni bir kopya sayısı yönetmesini söylemeniz yeterlidir:

$ 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

Burada bildirime dayalı yaklaşım kullanıldığını unutmayın. Yeni örnekleri başlatmak veya durdurmak yerine, her zaman kaç örneğin çalışması gerektiğini tanımlarsınız. Kubernetes uzlaştırma döngüleri, gerçekliğin istediğinizle eşleştiğinden emin olur ve gerekirse işlem yapar.

12. Hizmetinizde yükseltme yayınlama

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

Öncelikle uygulamayı değiştirelim. Cloud Shell'den kod düzenleyiciyi açın.

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

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

/jib/examples/micronaut/build.gradle içinde, bu satırı güncelleyerek resmimizin sürümünü 0.1'den 0.2'ye yükselteceğiz:

version '0.2'

Ardından, uygulamayı en son değişikliklerle yeniden oluşturun ve paketleyin:

$ ./gradlew jibDockerBuild

Ardından, görüntüyü etiketleyin ve kapsayıcı 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 almadan tam olarak yararlandığımız için bu güncellenmiş görüntüyü oluşturup göndermek çok daha hızlı olacaktır.

Artık Kubernetes'in, Replication Controller'ınızı uygulamanın yeni sürümüne sorunsuz bir şekilde güncellemesine hazırsınız. Çalışan kapsayıcınızın resim etiketini değiştirmek için mevcut hello-micronaut deployment öğesini düzenlemeniz ve resmi gcr.io/PROJECT_ID/micronaut-jib:0.1 öğesinden gcr.io/PROJECT_ID/micronaut-jib:0.2 öğesine değiştirmeniz gerekir.

Kubernetes'ten, uygulamanızın yeni sürümünü periyodik güncelleme ile kümenin tamamına tek seferde bir örnek dağıtmasını istemek için kubectl set image komutunu kullanabilirsiniz:

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

deployment.apps "hello-micronaut" image updated

Bu işlem sırasında hizmet kullanıcıları kesinti yaşayabilir. Ancak bu durum, yapılandırılmış bir durum denetimi olmamasından kaynaklanır. Bu biraz daha gelişmiş bir yapılandırmadır. Bu laboratuvarda durum denetimi eklemeyeceğiz.

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

13. Geri çek

Hata mı yaptınız? Uygulamanın yeni sürümünde bir hata mı var? Belki de yeni sürümde bir hata vardır ve hızlı bir şekilde geri almanız gerekir. Kubernetes ile önceki duruma kolayca geri dönebilirsiniz. Şu komutu çalıştırarak uygulamayı geri alalım:

$ kubectl rollout undo deployment/hello-micronaut

Hizmetin çıktısına bakarsanız ilk "Hello World" mesajımıza geri döneriz.

14. Özet

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

15. Tebrikler!

Google Kubernetes Engine'de Kubernetes'e yeni bir Apache Groovy / Micronaut web tabanlı mikro hizmet oluşturmayı ve dağıtmayı öğrendiniz.

Daha Fazla Bilgi

• Jib belgeleri ve örnekleri: https://github.com/GoogleContainerTools/jib/
• Micronaut 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
• Kubernetes ile ilgili daha uzun ve eksiksiz bir eğitim için bit.ly/k8s-lab adresini ziyaret edin. Bu eğitimde, tam yığınlı bir uygulamayı dağıtma süreci adım adım açıklanır.

Lisans

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