Men-deploy aplikasi Micronaut dalam container dengan Jib ke Google Kubernetes Engine

1. Ringkasan

Tentang Micronaut

Micronaut adalah framework full stack berbasis JVM modern untuk membangun aplikasi microservice dan serverless yang modular dan mudah diuji. Micronaut bertujuan untuk memberikan waktu mulai yang sangat baik, throughput yang cepat, dengan footprint memori yang minimal. Developer dapat mengembangkan dengan Micronaut di Java, Groovy, atau Kotlin.

Micronaut menyediakan:

• Waktu mulai yang cepat & konsumsi memori yang rendah — Framework IoC berbasis refleksi memuat dan meng-cache data refleksi untuk setiap kolom, metode, dan konstruktor dalam kode Anda, sedangkan dengan Micronaut, waktu mulai aplikasi dan konsumsi memori tidak terikat dengan ukuran codebase Anda.
• Klien HTTP deklaratif, reaktif, waktu kompilasi — Buat klien HTTP reaktif secara deklaratif, yang diimplementasikan pada waktu kompilasi, sehingga mengurangi konsumsi memori.
• Server HTTP non-blocking yang dibangun di Netty — Dengan kurva pembelajaran yang lancar, server HTTP Micronaut mempermudah pemaparan API yang dapat digunakan oleh klien HTTP.
• Pengujian yang cepat dan mudah — Siapkan server dan klien dengan mudah dalam uji unit Anda, dan jalankan secara instan.
• Injeksi dependensi dan AOP waktu kompilasi yang efisien — Micronaut menyediakan API pemrograman berorientasi aspek waktu kompilasi sederhana yang tidak menggunakan refleksi.
• Bangun aplikasi yang sepenuhnya reaktif dan tidak memblokir — Micronaut mendukung framework apa pun yang menerapkan Reactive Streams, termasuk RxJava, dan Reactor.

Untuk mengetahui informasi selengkapnya, kunjungi situs Micronaut.

Tentang Kubernetes

Kubernetes adalah project open source yang dapat berjalan di berbagai lingkungan, dari laptop hingga cluster multi node dengan ketersediaan tinggi, dari cloud publik hingga deployment lokal, dan dari virtual machine hingga server khusus (bare metal).

Di lab ini, Anda akan men-deploy microservice Micronaut berbasis Groovy sederhana ke Kubernetes yang berjalan di Kubernetes Engine.

Tujuan codelab ini adalah agar Anda dapat menjalankan microservice sebagai layanan yang direplikasi dan berjalan di Kubernetes. Anda mengambil kode yang telah dikembangkan di mesin Anda, mengubahnya menjadi image container Docker, lalu menjalankan image tersebut di Kubernetes Engine.

Berikut diagram berbagai bagian yang berperan dalam codelab ini untuk membantu Anda memahami cara kerja berbagai bagian tersebut. Gunakan ini sebagai referensi saat Anda melanjutkan codelab; semuanya akan masuk akal saat Anda mencapai akhir (tetapi Anda dapat mengabaikannya untuk saat ini).

Untuk tujuan codelab ini, dengan menggunakan lingkungan terkelola seperti Kubernetes Engine (versi Kubernetes yang dihosting Google dan berjalan di Compute Engine), Anda dapat lebih berfokus pada pengalaman menggunakan Kubernetes daripada menyiapkan infrastruktur dasarnya.

Jika Anda tertarik untuk menjalankan Kubernetes di mesin lokal, seperti laptop pengembangan, sebaiknya pelajari Minikube. Hal ini menawarkan penyiapan sederhana cluster Kubernetes node tunggal untuk tujuan pengembangan dan pengujian. Anda dapat menggunakan Minikube untuk mempelajari codelab ini jika mau.

Tentang Jib

Jib adalah alat open source yang memungkinkan Anda mem-build image Docker dan OCI untuk aplikasi Java Anda. Tersedia sebagai plugin untuk Maven dan Gradle, serta sebagai library Java.

Jib bertujuan untuk menjadi:

• Cepat — Deploy perubahan Anda dengan cepat. Jib memisahkan aplikasi Anda menjadi beberapa lapisan, memisahkan dependensi dari class. Sekarang Anda tidak perlu menunggu Docker membangun ulang seluruh aplikasi Java - cukup deploy lapisan yang berubah.
• Dapat direproduksi — Membangun ulang image container dengan konten yang sama akan selalu menghasilkan image yang sama. Jangan pernah memicu update yang tidak perlu lagi.
• Tanpa daemon — Mengurangi dependensi CLI Anda. Bangun image Docker Anda dari dalam Maven atau Gradle dan kirim ke registry pilihan Anda. Tidak perlu lagi menulis Dockerfile dan memanggil docker build/push.

Anda dapat menemukan informasi selengkapnya tentang Jib di halaman project GitHub.

Tentang tutorial ini

Tutorial ini menggunakan kode contoh dari alat Jib untuk membangun container bagi aplikasi Java.

Contohnya adalah layanan hello world sederhana, menggunakan framework Micronaut, dan bahasa pemrograman Apache Groovy.

Yang akan Anda pelajari

• Cara mengemas aplikasi Java sederhana sebagai container Docker menggunakan Jib
• Cara membuat cluster Kubernetes di Kubernetes Engine.
• Cara men-deploy layanan Micronaut ke Kubernetes di Kubernetes Engine
• Cara meningkatkan skala layanan dan meluncurkan upgrade.
• Cara mengakses dasbor Grafis Kubernetes.

Yang Anda butuhkan

• Project Google Cloud Platform
• Browser, seperti Chrome atau Firefox
• Pemahaman tentang editor teks Linux standar seperti Vim, EMACs, atau Nano

Bagaimana Anda akan menggunakan tutorial ini?

Hanya membacanya Membacanya dan menyelesaikan latihan

Sejauh mana pengalaman Anda membuat aplikasi web HTML/CSS?

Pemula Menengah Mahir

Bagaimana penilaian Anda terhadap pengalaman menggunakan layanan Google Cloud Platform?

Pemula Menengah Mahir

2. Penyiapan dan Persyaratan

Penyiapan lingkungan mandiri

1. Login ke Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. (Jika belum memiliki akun Gmail atau G Suite, Anda harus membuatnya.)

Catatan: Anda dapat mengakses Cloud Console dengan mudah dengan mengingat URL-nya, yaitu console.cloud.google.com.

Ingat project ID, nama unik di semua project Google Cloud (maaf, nama di atas telah digunakan dan tidak akan berfungsi untuk Anda!) Project ID tersebut selanjutnya akan dirujuk di codelab ini sebagai PROJECT_ID.

Catatan: Jika menggunakan akun Gmail, Anda dapat menyetel lokasi default ke Tidak ada organisasi. Jika Anda menggunakan akun G Suite, pilih lokasi yang sesuai untuk organisasi Anda.

2. Selanjutnya, Anda harus mengaktifkan penagihan di Cloud Console untuk menggunakan resource Google Cloud.

Menjalankan operasi dalam codelab ini seharusnya tidak memerlukan banyak biaya, bahkan mungkin tidak sama sekali. Pastikan untuk mengikuti petunjuk yang ada di bagian "Membersihkan" yang memberi tahu Anda cara menonaktifkan resource sehingga tidak menimbulkan penagihan di luar tutorial ini. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.

3. Mendapatkan kode sumber contoh Micronaut

Setelah Cloud Shell diluncurkan, Anda dapat menggunakan command line untuk meng-clone kode sumber contoh di direktori utama, dan cd ke direktori yang berisi layanan contoh:

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

Repositori project Jib berisi project contoh untuk framework lain juga, seperti Spring Boot atau Vert.x, jika Anda ingin mencoba contoh lainnya.

4. Melihat kode secara sekilas

Layanan sederhana Micronaut kami terdiri dari pengontrol yang menghasilkan pesan Hello World yang terkenal:

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

Pengontrol HelloController merespons permintaan di jalur /hello, dan metode index() menerima permintaan HTTP GET.

Class pengujian Spock juga tersedia untuk memeriksa apakah pesan yang benar diberikan dalam output.

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"
    }
}

Lebih dari sekadar pengujian unit sederhana, pengujian ini benar-benar menjalankan stack server Micronaut yang sama (berdasarkan framework Netty) yang dijalankan dalam produksi. Jadi, perilaku kode Anda akan sama di produk seperti dalam pengujian Anda.

Untuk menjalankan pengujian, Anda dapat menjalankan perintah berikut untuk memastikan semuanya berjalan dengan baik:

./gradlew test

5. Menjalankan Aplikasi Secara Lokal

Anda dapat memulai layanan Micronaut secara normal dengan perintah Gradle berikut:

$ ./gradlew run

Setelah aplikasi dimulai, Anda dapat membuka instance Cloud Shell tambahan berkat ikon + kecil, lalu memeriksa dengan curl bahwa Anda mendapatkan output yang diharapkan:

$ curl localhost:8080/hello

Anda akan melihat pesan "Hello World" sederhana muncul.

6. Mengemas aplikasi sebagai container Docker dengan Jib

Selanjutnya, siapkan aplikasi Anda untuk dijalankan di Kubernetes. Untuk tujuan tersebut, kita akan memanfaatkan Jib untuk melakukan pekerjaan berat bagi kita, karena kita tidak perlu menyentuh Dockerfile sendiri.

Mari jalankan perintah untuk membangun container kita:

$ ./gradlew jibDockerBuild

Berikut output yang akan Anda lihat:

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 membangun image Docker dengan lapisan yang berbeda: untuk dependensi, untuk resource, dan untuk kode yang dikompilasi. Jadi, misalnya, jika Anda mengubah kode, hanya lapisan dengan class yang dikompilasi yang akan diubah, sehingga menghemat waktu build dengan menggunakan kembali lapisan sebelumnya yang tidak diubah.

Setelah image dibuat, mari kita periksa apakah kita dapat melihat pesan halo, dengan menjalankan image Docker di tab pertama Cloud Shell:

$ 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

Layanan kita sudah berjalan, jadi kita sekarang dapat meluncurkan perintah curl, di tab Cloud Shell kedua, untuk melihat apakah layanan berfungsi seperti yang diharapkan:

$ curl localhost:8080/hello
Hello World

Anda dapat menghentikan container dengan menekan Ctrl+C di Cloud Shell.

7. Mengirim layanan yang di-container ke registry

Setelah image berfungsi seperti yang diinginkan, Anda dapat mengirimkannya ke Google Container Registry, repositori pribadi untuk image Docker Anda yang dapat diakses dari setiap project Google Cloud (tetapi juga dari luar Google Cloud Platform).

Sebelum dapat melakukan push ke registry, pastikan Container Registry diaktifkan untuk project kita dengan membuka Tools > Container Registry. Jika belum diaktifkan, Anda akan melihat dialog berikut, lalu klik "Enable Container Registry API" untuk mengaktifkannya:

Setelah registry siap, untuk mengirim image ke registry, jalankan perintah berikut:

$ 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

Perintah di atas memungkinkan gcloud SDK mengonfigurasi dan memberi otorisasi docker untuk mengirim image ke instance Container Registry Anda, memberi tag pada image untuk menunjukkan lokasinya di registry, lalu mengirimkannya ke registry.

Jika semuanya berjalan lancar, setelah beberapa saat, Anda akan dapat melihat image container yang tercantum di konsol: Alat > Container Registry. Pada tahap ini, Anda kini memiliki image Docker yang tersedia di seluruh project yang dapat diakses dan diatur oleh Kubernetes seperti yang akan Anda lihat dalam beberapa menit.

Perhatikan bahwa meskipun di sini kita menggunakan domain generik untuk registry (gcr.io), Anda juga dapat lebih spesifik tentang zona dan bucket yang akan digunakan. Detailnya didokumentasikan di sini: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

8. Buat cluster Anda

Oke, Anda kini siap membuat cluster Kubernetes Engine, tetapi sebelumnya, buka bagian Google Kubernetes Engine di konsol web dan tunggu hingga sistem diinisialisasi (hanya perlu beberapa detik).

Cluster terdiri dari server Kubernetes API master yang dikelola oleh Google dan serangkaian worker node. Node pekerja adalah mesin virtual Compute Engine. Mari gunakan CLI gcloud dari sesi Cloud Shell Anda untuk membuat cluster dengan dua node n1-standard-1 (proses ini memerlukan waktu beberapa menit untuk diselesaikan):

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

Pada akhirnya, Anda akan melihat cluster yang dibuat.

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

Atau, Anda dapat membuat cluster ini melalui Konsol yang ditampilkan di atas: Compute > Kubernetes Engine > Container Clusters > Create a container cluster.

Anda dapat membuat cluster di Zona lain, tetapi sebaiknya tetap berada di region yang sama dengan bucket penyimpanan yang digunakan oleh container registry (lihat langkah sebelumnya).

Sekarang Anda akan memiliki cluster Kubernetes yang berfungsi penuh dan didukung oleh Google Kubernetes Engine:

Sekarang saatnya men-deploy aplikasi dalam container Anda sendiri ke cluster Kubernetes. Mulai sekarang, Anda akan menggunakan command line kubectl (yang sudah disiapkan di lingkungan Cloud Shell Anda). Bagian codelab ini memerlukan versi klien dan server Kubernetes 1.2 atau yang lebih tinggi. kubectl version akan menampilkan versi perintah saat ini.

9. Men-deploy aplikasi ke Kubernetes

Deployment Kubernetes dapat membuat, mengelola, dan menskalakan beberapa instance aplikasi Anda menggunakan image container yang baru saja Anda buat. Buat deployment aplikasi Anda ke Kubernetes menggunakan perintah kubectl create deployment:

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

Untuk melihat deployment yang baru saja Anda buat, cukup jalankan:

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

Untuk melihat instance aplikasi yang dibuat oleh deployment, jalankan perintah ini:

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

Pada tahap ini, Anda akan menjalankan container di bawah kontrol Kubernetes, tetapi Anda masih harus membuatnya dapat diakses oleh dunia luar.

10. Mengizinkan traffic eksternal

Secara default, pod hanya dapat diakses oleh IP internalnya di dalam cluster. Agar container hello-micronaut dapat diakses dari luar jaringan virtual kubernetes, Anda harus mengekspos pod sebagai layanan kubernetes.

Dari Cloud Shell, Anda dapat mengekspos pod ke internet publik dengan perintah kubectl expose yang dikombinasikan dengan flag --type=LoadBalancer. Flag ini diperlukan untuk pembuatan IP yang dapat diakses secara eksternal :

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

Flag yang digunakan dalam perintah ini menentukan bahwa Anda akan menggunakan load balancer yang disediakan oleh infrastruktur pokok (dalam hal ini Load Balancer Compute Engine). Perhatikan bahwa Anda mengekspos deployment, bukan pod secara langsung. Tindakan ini akan menyebabkan layanan yang dihasilkan menyeimbangkan beban traffic di semua pod yang dikelola oleh deployment (dalam hal ini hanya 1 pod, tetapi Anda akan menambahkan lebih banyak replika nanti).

Master Kubernetes membuat load balancer dan aturan penerusan, kumpulan target, serta aturan firewall Compute Engine terkait untuk membuat layanan dapat diakses sepenuhnya dari luar Google Cloud Platform.

Untuk menemukan alamat IP layanan yang dapat diakses secara publik, cukup minta kubectl untuk mencantumkan semua layanan cluster:

$ 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 mungkin memerlukan waktu beberapa menit untuk tersedia dan terlihat. Jika EXTERNAL-IP tidak ada, tunggu beberapa menit dan coba lagi.

Perhatikan bahwa ada 2 alamat IP yang tercantum untuk layanan Anda, keduanya melayani port 8080. Salah satunya adalah IP internal yang hanya terlihat di dalam jaringan virtual cloud Anda; yang lainnya adalah IP load-balanced eksternal. Dalam contoh ini, alamat IP eksternal adalah aaa.bbb.ccc.ddd.

Sekarang Anda dapat mengakses layanan dengan mengarahkan browser ke alamat ini: http://<EXTERNAL_IP>:8080/hello

11. Menskalakan layanan Anda

Salah satu fitur canggih yang ditawarkan oleh Kubernetes adalah kemudahan dalam menskalakan aplikasi Anda. Misalnya, Anda tiba-tiba memerlukan kapasitas yang lebih besar untuk aplikasi; Anda cukup memberi tahu replication controller untuk mengelola sejumlah replika baru untuk instance aplikasi Anda:

$ 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

Perhatikan pendekatan deklaratif di sini — alih-alih memulai atau menghentikan instance baru, Anda mendeklarasikan berapa banyak instance yang harus berjalan setiap saat. Loop rekonsiliasi Kubernetes hanya memastikan bahwa kenyataan sesuai dengan yang Anda minta dan mengambil tindakan jika diperlukan.

12. Meluncurkan upgrade ke layanan Anda

Pada suatu saat, aplikasi yang telah Anda deploy ke produksi akan memerlukan perbaikan bug atau fitur tambahan. Kubernetes hadir untuk membantu Anda men-deploy versi baru ke produksi tanpa memengaruhi pengguna Anda.

Pertama, mari kita modifikasi aplikasi. Buka editor kode dari Cloud Shell.

Buka /jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy, lalu perbarui nilai respons:

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

Di /jib/examples/micronaut/build.gradle, kita akan mengupgrade versi gambar dari 0.1 menjadi 0.2 dengan memperbarui baris ini:

version '0.2'

Kemudian, bangun ulang dan kemas aplikasi dengan perubahan terbaru:

$ ./gradlew jibDockerBuild

Beri tag dan kirim image ke dalam container image registry:

$ 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

Membangun dan mengirimkan image yang diupdate ini akan jauh lebih cepat karena kita memanfaatkan sepenuhnya caching.

Sekarang Anda siap agar Kubernetes mengupdate replication controller Anda dengan lancar ke versi baru aplikasi. Untuk mengubah label gambar pada container yang sedang berjalan, Anda perlu mengedit hello-micronaut deployment yang ada dan mengubah gambar dari gcr.io/PROJECT_ID/micronaut-jib:0.1 menjadi gcr.io/PROJECT_ID/micronaut-jib:0.2.

Anda dapat menggunakan perintah kubectl set image untuk meminta Kubernetes men-deploy versi baru aplikasi Anda di seluruh cluster satu instance dalam satu waktu dengan update bertahap:

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

deployment.apps "hello-micronaut" image updated

Selama hal ini terjadi, pengguna layanan mungkin mengalami gangguan. Namun, hal itu terjadi karena tidak ada health check yang dikonfigurasi. Konfigurasi tersebut sedikit lebih rumit. Kita tidak akan menambahkan health check di lab ini.

Periksa http://EXTERNAL_IP:8080 lagi untuk melihat bahwa respons baru ditampilkan.

13. Roll back

Ups — apakah Anda melakukan kesalahan dengan aplikasi versi baru? Mungkin versi baru berisi error dan Anda perlu melakukan rollback dengan cepat. Dengan Kubernetes, Anda dapat melakukan roll back ke status sebelumnya dengan mudah. Lakukan rollback aplikasi dengan menjalankan:

$ kubectl rollout undo deployment/hello-micronaut

Jika Anda melihat output layanan, kita akan kembali ke pesan "Hello World" awal.

14. Ringkasan

Pada langkah ini, Anda akan menyiapkan layanan hello world Micronaut berbasis Apache Groovy sederhana dan menjalankannya langsung dari dalam Cloud Shell, mengemasnya sebagai container dengan Jib, dan men-deploy-nya ke Google Kubernetes Engine.

15. Selamat!

Anda telah mempelajari cara mem-build dan men-deploy microservice berbasis web Apache Groovy / Micronaut baru ke Kubernetes di Google Kubernetes Engine.

Pelajari Lebih Lanjut

• Dokumentasi dan contoh Jib: https://github.com/GoogleContainerTools/jib/
• Situs Micronaut: http://micronaut.io/
• Java di Google Cloud Platform: https://cloud.google.com/java/
• Untuk contoh Java: https://cloud.google.com/java/samples
• Untuk tutorial Kubernetes yang lebih panjang dan lengkap, lihat bit.ly/k8s-lab yang akan memandu Anda men-deploy aplikasi full-stack.

Lisensi

Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.