Menggunakan halaman Applications GKE di konsol Google Cloud

Tutorial ini menjelaskan cara menggunakan halaman Applications Google Kubernetes Engine (GKE) di Konsol Google Cloud .

Saat Anda mengadopsi Kubernetes untuk banyak aplikasi dan resource, identifikasi dan pelacakan berbagai komponen yang terkait dengan satu aplikasi mungkin cukup sulit. Saat Anda men-deploy beberapa aplikasi di setiap namespace, mungkin sulit untuk mengetahui resource apa yang terkait dengan aplikasi tertentu. Selain itu, Anda harus sering menelusuri di beberapa lokasi untuk menemukan dokumentasi dan metadata yang menjelaskan aplikasi tersebut, pemiliknya, dan caranya berinteraksi dengan layanan.

GKE membantu mengatasi tantangan ini dengan halaman Applications:

Tampilan sebagian halaman Applications yang menampilkan daftar aplikasi beserta berbagai properti.

Halaman Applications adalah resource independen dalam arsitektur yang menjelaskan metadata sistem Anda. Anda bisa menggunakan halaman ini untuk mengatur resource secara visual tanpa mengubah arsitekturnya. Dengan menentukan nilai dalam file YAML, Anda dapat mengelompokkan semua resource aplikasi dan mencantumkan metadata penting untuk tim operasi Anda. Membuat, memodifikasi, dan menghapus file YAML tidak memengaruhi resource yang ada, sehingga Anda dapat langsung menggunakan resource tanpa risiko terhadap sistem.

Untuk mendemonstrasikan halaman ini, tutorial ini menunjukkan cara menerapkan resource Aplikasi Kubernetes pada aplikasi dan menambahkan metadata yang ditentukan pengguna untuk mengatur dan menyederhanakan pengelolaan aplikasi di GKE.

Tutorial ini ditujukan bagi developer yang membuat aplikasi untuk dijalankan di GKE. Anda dianggap sudah memahami konsep dasar Kubernetes dan memiliki pengalaman menulis file YAML resource Kubernetes.

Tujuan

Memperkenalkan resource Aplikasi Kubernetes.
Menambahkan resource Aplikasi Kubernetes ke arsitektur yang ada.
Membuat dan melihat informasi kustom sebuah aplikasi melalui KonsolGoogle Cloud .

Biaya

Dalam dokumen ini, Anda akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Pengguna Google Cloud baru mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, baca bagian Pembersihan.

Sebelum memulai

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Kubernetes Engine APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Anda dapat menjalankan perintah untuk tutorial ini di Cloud Shell atau Editor Cloud Shell.

Menyiapkan lingkungan Anda
1. Di Cloud Shell, tetapkan variabel lingkungan untuk project Anda:
```
export PROJECT_ID=PROJECT_ID
gcloud config set core/project $PROJECT_ID
gcloud config set compute/zone us-central1-c
```
  Ganti PROJECT_ID dengan project ID Google Cloud Anda.
2. Buat cluster GKE:
```
gcloud container clusters create sample-cluster
```
  Untuk tutorial ini, Anda dapat menjalankan aplikasi di cluster GKE default.
Menginstal aplikasi contoh

Dalam tutorial ini, Anda akan menyimulasikan beberapa aplikasi yang berjalan di namespace yang sama menggunakan aplikasi contoh Nginx dan Bank of Anthos.
1. Di Cloud Shell, instal aplikasi contoh Nginx:
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/web/web.yaml
```
  Perintah ini membuat resource StatefulSet yang disebut web dan layanan yang disebut nginx. Di Konsol Google Cloud , Anda dapat melihat resource ini di halaman Workloads dan Services & Ingress GKE.
2. Clone repositori GitHub yang berisi aplikasi contoh Bank of Anthos:
```
git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
cd bank-of-anthos
```
3. Buat kunci SSH dan simpan sebagai Secret Kubernetes:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```
  Aplikasi contoh Bank of Anthos memerlukan kunci SSH agar dapat berjalan.
4. Deploy aplikasi contoh ke cluster Anda:
```
kubectl apply -f kubernetes-manifests
```
  Setelah beberapa saat, Anda dapat melihat resource aplikasi tersebut di halaman berikut di Konsol Google Cloud :
  - Halaman Workloads
  - Halaman Services & Ingress
  Perhatikan hal berikut:
  - Resource untuk aplikasi contoh Nginx dan Bank of Anthos bercampur.
  - Belum ada resource yang ditampilkan di halaman Applications. Halaman Applications akan terisi pada langkah-langkah berikutnya.
Menyiapkan GKE

Resource yang ditampilkan halaman Applications ditentukan berdasarkan jenis resource Aplikasi Kubernetes, yaitu definisi resource kustom (CRD) yang disediakan oleh project Kubernetes open source. Secara default, CRD Aplikasi tidak diaktifkan di Kubernetes. Beberapa layanan di GKE, seperti Marketplace dan Application Deployment, menginstal CRD Aplikasi, tetapi jika Anda tidak menggunakan layanan tersebut, CRD Aplikasi tidak tersedia secara default.

Untuk menginstal CRD Aplikasi, lakukan langkah-langkah berikut:
1. Di Cloud Shell, terapkan CRD Aplikasi satu kali di setiap cluster:
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/application/master/deploy/kube-app-manager-aio.yaml
```
2. (Opsional) Setelah perintah selesai, lihat CRD Aplikasi di cluster:
```
kubectl get crd
```
  Output berikut adalah daftar CRD yang terinstal, termasuk applications.app.k8s.io:
```
NAME                                    CREATED AT
applications.app.k8s.io                 2020-07-24T19:32:20Z
backendconfigs.cloud.google.com         2020-07-24T19:28:40Z
managedcertificates.networking.gke.io   2020-07-24T19:28:57Z
scalingpolicies.scalingpolicy.kope.io   2020-07-24T19:28:57Z
updateinfos.nodemanagement.gke.io       2020-07-24T19:28:57Z
```
Mencantumkan resource aplikasi

Setelah CRD Aplikasi tersedia di cluster, langkah berikutnya adalah membuat dan men-deploy instance resource Aplikasi.

Karena resource Aplikasi merupakan resource Kubernetes, strukturnya mirip dengan resource Kubernetes lainnya, termasuk kolom dan opsi untuk apiVersion, kind, metadata, dan spec:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: ...
spec:
   ...
```
Di bagian berikut, Anda akan menggunakan berbagai kolom dan opsi yang tersedia dalam resource Aplikasi.

Membuat resource dasar Aplikasi

Anda dapat menambahkan resource Application ke kumpulan resource yang sudah ada. Dalam tutorial ini, Anda akan memulai dengan resource kosong dan mengisi setiap bagian.
1. Di Cloud Shell, buat dan edit file application.yaml di direktori kubernetes-manifests:
```
touch kubernetes-manifests/application.yaml
edit kubernetes-manifests/application.yaml
```
  Editor Cloud Shell akan terbuka dan menampilkan file kosong.
2. Tempel baris berikut untuk menentukan aplikasi pertama Anda:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
```
3. Di panel menu Cloud Shell, klik Open Terminal.
4. Di Cloud Shell, terapkan resource:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
5. Di Konsol Google Cloud , buka halaman Applications.
  
  Buka Applications
  
  Halaman Applications menampilkan resource yang telah ditambahkan:
Mencantumkan resource berdasarkan komponen

Halaman Applications menampilkan aplikasi Bank of Anthos. Saat mengklik bank-of-anthos di kolom Name, Anda akan melihat informasi dasar tentang aplikasi tersebut:

Anda dapat menambahkan berbagai jenis komponen untuk ditampilkan di KonsolGoogle Cloud . Misalnya, untuk menampilkan Service, Deployment, dan StatefulSet, edit bagian componentKinds dari definisi application.yaml—misalnya sebagai berikut:
```
spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet
```
Pada langkah-langkah berikut, Anda akan menambahkan komponen ini ke definisi resource Bank of Anthos:
1. Di panel menu Cloud Shell, klik Open Editor.
2. Di Editor Cloud Shell, timpa isi file kubernetes-manifests/application.yaml dengan menempel perintah berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet
```
  Penambahan bagian spec akan menambahkan Service, Deployment, dan StatefulSet ke definisi aplikasi Anda.
3. Di Cloud Shell, terapkan resource:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
4. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Komponen dari jenis tertentu akan ditampilkan:
Memfilter resource dengan pemilih

Pada tahap tutorial ini, daftar komponen mencantumkan semua resource kedua aplikasi contoh untuk kumpulan komponen yang ditentukan dari seluruh namespace. Misalnya, diagram berikut menunjukkan Service nginx dari aplikasi contoh Nginx dan Deployment transactionhistory dari aplikasi contoh Bank of Anthos:

Untuk memastikan hanya resource dari satu aplikasi yang ditampilkan, misalnya aplikasi Bank of Anthos, Anda dapat menggunakan pemilih untuk mengidentifikasi resource tertentu. Untuk melihat cara kerja pemilih, tambahkan label ke resource dengan mengikuti langkah-langkah berikut:
1. Di Cloud Shell, buka file frontend.yaml:
```
edit kubernetes-manifests/frontend.yaml
```
2. Di Editor Cloud Shell, tempel entri label berikut setelah baris 18:
```
labels:
    app.kubernetes.io/name: "bank-of-anthos"
```
  Bagian metadata akan terlihat seperti berikut:
```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
```
  File application.yaml yang sudah selesai akan terlihat seperti berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet
```
3. Di Cloud Shell, terapkan resource:
```
kubectl apply -f kubernetes-manifests/
```
4. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Satu-satunya resource yang cocok dengan label tertentu akan ditampilkan:
Menerapkan label ke semua resource dengan kustomize

Menerapkan label secara manual ke setiap resource dalam aplikasi bisa menjemukan. Langkah-langkah berikut menunjukkan cara menggunakan kustomize untuk menambahkan label secara efisien ke semua resource:
1. Di Cloud Shell, download kustomize:
```
curl -s "https://raw.githubusercontent.com/\
kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
```
2. Buat dan edit file kustomization.yaml:
```
touch kubernetes-manifests/kustomization.yaml
edit kubernetes-manifests/kustomization.yaml
```
3. Di Editor Cloud Shell, tambahkan baris berikut ke kustomization.yaml:
```
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
- accounts-db.yaml
- application.yaml
- balance-reader.yaml
- config.yaml
- contacts.yaml
- frontend.yaml
- ledger-db.yaml
- ledger-writer.yaml
- loadgenerator.yaml
- transaction-history.yaml
- userservice.yaml

commonLabels:
    app.kubernetes.io/name: "bank-of-anthos"
```
  Dalam definisi kustomization.yaml ini, Anda menentukan resource mana yang akan dikenai perubahan dan perubahan apa yang akan dilakukan. Dalam hal ini, Anda menentukan bahwa semua resource harus memiliki label yang sama, yaitu app.kubernetes.io/name: "bank-of-anthos".
4. Di Cloud Shell, hapus resource lama:
```
kubectl delete -f kubernetes-manifests/
```
  Anda harus menghapus resource lama sebelum menerapkan resource baru yang ditentukan dalam kustomization.yaml.
5. Terapkan resource menggunakan flag kustomize, bukan flag file:
```
./kustomize build kubernetes-manifests/ | kubectl apply -f -
```
6. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Halaman detail menampilkan resource untuk aplikasi contoh Bank of Anthos dan tidak ada resource dari aplikasi contoh Nginx:
Menambahkan metadata berguna di tampilan

Anda dapat menampilkan metadata kustom untuk sebuah aplikasi di KonsolGoogle Cloud . Anda dapat mencantumkan fungsi, pemilik, tempat menemukan informasi lebih lanjut, dan cara login ke aplikasi tersebut. Informasi semacam ini berguna untuk berbagai kasus penggunaan—misalnya, jika Anda mengoperasikan banyak aplikasi dalam organisasi Anda.

Bagian berikut menjelaskan beberapa metadata yang dapat ditambahkan.

Menambahkan deskripsi dan dokumentasi

Anda dapat menambahkan deskripsi dan link yang muncul di panel Application info. Untuk mengakses panel ini dari halaman Details, klik Show Info Panel.

Untuk menampilkan informasi di panel ini, tentukan elemen seperti description dan links di bagian descriptor file application.yaml Anda.
```
descriptor:
    description:
    links:
    - description:
      url:
```
Untuk mengubah bagian descriptor, lakukan langkah-langkah berikut:
1. Di Editor Cloud Shell, timpa isi file application.yaml dengan menempel perintah berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    description: |-
        This application simulates a bank's payment processing network using
        [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and
        simulate transactions between accounts. Bank of Anthos was developed
        to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
```
2. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
3. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
4. Untuk meninjau perubahan, klik Show Info Panel.
  
  Panel Application info menampilkan deskripsi dan daftar dokumen:
Mencantumkan jenis software

Halaman Applications mencantumkan kolom (Software) untuk jenis software dalam daftar aplikasi. Kolom ini dapat disesuaikan untuk membantu mengatur dan mengategorikan aplikasi Anda sesuai dengan kebutuhan. Misalnya, Anda dapat menunjukkan bahwa software tersebut bersifat internal atau eksternal. Atau, jika ada beberapa aplikasi yang dibangun dari jenis dasar yang sama, Anda dapat menentukan jenis dasar apa yang diterapkan aplikasi.

Untuk menambahkan deskripsi kustom ke jenis software, gunakan kolom type di bagian descriptor file application.yaml:
```
 descriptor:
    type: External App
```
Anda dapat menampilkan nilai untuk type sebagai hyperlink di KonsolGoogle Cloud . Tentukan URL hyperlink menggunakan entri pertama dari bagian links. Pada langkah-langkah berikut, Anda akan memperbarui bagian links seperti berikut:
```
    links:
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
```
1. Di Editor Cloud Shell, timpa isi application.yaml dengan menempel perintah berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
```
2. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
3. Di Konsol Google Cloud , buka halaman Applications.
  
  Buka Applications
  
  External App ditampilkan di kolom Software:
Mencantumkan versi aplikasi

Bagian utama halaman Applications mencantumkan kolom untuk versi. Dalam praktiknya, nilai kolom ini diperbarui secara terprogram untuk menunjukkan versi sebenarnya yang di-deploy.

Untuk mengisi kolom versi, cantumkan kolom version di bagian descriptor seperti dalam contoh berikut:
```
  descriptor:
    type: External App
    version: "2.3.2"
```
Pada langkah-langkah berikut, Anda akan menambahkan kolom untuk versi aplikasi.
1. Di Editor Cloud Shell, timpa isi file application.yaml dengan menempel perintah berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
```
2. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
3. Di Konsol Google Cloud , buka halaman Applications.
  
  Buka Applications
  
  Kolom Version untuk aplikasi Bank of Anthos ditampilkan sebagai 2.3.2:
Menambahkan detail pengelola

Pada langkah ini, Anda akan menambahkan teks statis kustom ke bagian utama halaman Applications. Anda menentukan detail ini di bagian info file application.yaml sebagai berikut:
```
  info:
  - name: LABEL
    value: STRING
```
Untuk mencantumkan nilai statis, masukkan detail untuk LABEL dan STRING di bagian info. Misalnya, Anda dapat memasukkan Owner untuk name dan John Smith untuk value.
1. Di Editor Cloud Shell, timpa isi application.yaml dengan menempel perintah berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith
```
2. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
3. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Halaman detail mencantumkan pemilik aplikasi Bank of Anthos:
Mengekspos endpoint aplikasi

Selain nilai statis, Anda dapat mengekspos nilai dinamis dari Deployment itu sendiri. Pada langkah-langkah berikut, Anda akan menampilkan alamat IP load balancer sehingga siapa pun yang melihat halaman detail aplikasi dapat mengakses aplikasi itu secara langsung.

Untuk menampilkan nilai ini, gunakan spesifikasi serviceRef. Spesifikasi valid lainnya mencakup configMapKeyRef, ingressRef, dan secretKeyRef.

Dalam spesifikasi serviceRef, cantumkan nilai dinamis ini menggunakan jenis Reference. Untuk tutorial ini, spesifikasi untuk serviceRef adalah sebagai berikut:
```
 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
```
Anda dapat mengganti nilai berikut:
- LABEL: label yang mendeskripsikan instance Reference tertentu—misalnya App Frontend URL
- SERVICE_NAME: nama yang mengidentifikasi Service$mdash; misalnya frontend
- DATA_LOCATION: lokasi data di Service—misalnya status.loadBalancer.ingress[0].ip
Spesifikasi serviceRef dan ingressRef juga mendukung elemen path. Jika URL Anda memerlukan detail terkait jalur, cantumkan detail tersebut di kolom path:
```
 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin
```
Alamat IP dan jalur endpoint disambung—misalnya 35.202.90.0/wp-admin.

Anda juga dapat mewajibkan penggunaan HTTP atau HTTPS menggunakan kolom protocol sebagai berikut:
```
 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin
        protocol: HTTPS
```
Detail ini menghasilkan URL berikut:
```
https://35.202.90.0/wp-admin
```
Pada langkah-langkah berikut, Anda akan menggunakan serviceRef untuk mengekspos alamat IP load balancer Service aplikasi Bank of Anthos:
1. Di Editor Cloud Shell, timpa isi file application.yaml dengan kode berikut:
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith
  - name: App Frontend URL
    type: Reference
    valueFrom:
      serviceRef:
        name: frontend
        fieldPath: status.loadBalancer.ingress[0].ip
        protocol: HTTPS
```
2. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
3. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Halaman detail mencantumkan alamat IP endpoint untuk aplikasi Bank of Anthos:
Memberikan kredensial akses

Seperti yang disebutkan sebelumnya, Anda dapat mengekspos Secret Kubernetes melalui KonsolGoogle Cloud menggunakan elemen secretKeyRef. Dalam tutorial ini, Anda akan memberikan nama pengguna dan sandi kepada operator agar dia dapat login ke aplikasi.
1. Di Cloud Shell, buat Secret:
```
kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
```
  Catatan: Secret ini tidak digunakan di aplikasi. Anda membuatnya untuk tujuan demonstrasi dalam tutorial ini.
2. Di Editor Cloud Shell, timpa isi file application.yaml dengan menempel perintah di bawah. Perubahan ini mencakup referensi ke nama pengguna dan sandi dalam anotasi secretKeyRef.
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith
  - name: App Frontend URL
    type: Reference
    valueFrom:
      serviceRef:
        name: frontend
        fieldPath: status.loadBalancer.ingress[0].ip
        protocol: HTTPS
  - name: TestUser username
    type: Reference
    valueFrom:
      secretKeyRef:
        name: boa-access
        key: boa-user

  - name: TestUser password
    type: Reference
    valueFrom:
      secretKeyRef:
        name: boa-access
        key: boa-pass
```
3. Di Cloud Shell, deploy resource Aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
4. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
5. Klik preview secret data. Nama pengguna dan sandi akan ditampilkan:
Kemampuan untuk menampilkan data Secret dapat menjadi fitur berguna bagi tim operasi Anda. Namun, kemampuan untuk melihat Secret ini diatur oleh izin akses Identity and Access Management (IAM) untuk halaman detail GKE. Siapa saja yang memiliki izin untuk melihat cluster juga dapat melihat Secret. Oleh karena itu, pertimbangkan dengan cermat apa yang Anda ekspos.

Menambahkan ikon aplikasi

Agar aplikasi terlihat lebih menarik, Anda dapat mencantumkan logo yang ditampilkan di daftar aplikasi dan halaman detail. Untuk mencantumkan logo, tentukan URI data gambar dalam anotasi kubernetes-engine.cloud.google.com/icon.

Tutorial ini tidak mencakup cara mengonversi gambar menjadi URI data. Namun, penelusuran Google terkait "mengonversi gambar menjadi URI data" akan menampilkan berbagai utilitas untuk membantu Anda menghasilkan string data dari gambar. Karena URI data untuk gambar yang digunakan di bagian ini sangat panjang, tidaklah praktis untuk menyertakannya dalam tutorial. URI data lengkapnya dapat dilihat dalam file application.yaml yang sudah selesai. String URI data diawali seperti ini: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... dan diakhiri dengan K5CYII=. Pastikan untuk tidak menyertakan tanda kutip atau karakter HTML di akhir.

File application.yaml lengkap tersedia sebagai gist untuk referensi Anda.

Untuk menambahkan ikon, perbarui bagian metadata pada application.yaml:
1. Salin kode berikut:
```
annotations:
  kubernetes-engine.cloud.google.com/icon: >-
    data:image/png;base64,DATA_URI
```
  Ganti DATA_URI dengan string yang ditemukan dalam file application.yaml yang telah selesai yang disebut sebelumnya.
2. Di Editor Cloud Shell, tempel kode yang Anda salin setelah bagian labels di bagian metadata pada application.yaml.
  
  Bagian application.yaml tersebut terlihat mirip dengan berikut, dengan DATA_URI mewakili nilai URI data.
```
apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
  annotations:
    kubernetes-engine.cloud.google.com/icon: >-
      data:image/png;base64,DATA_URI
spec:
```
3. Di Cloud Shell, deploy resource aplikasi:
```
kubectl apply -f kubernetes-manifests/application.yaml
```
4. Di Konsol Google Cloud , buka halaman Applications.
  
  Buka Applications
  
  Logo ditampilkan dalam daftar aplikasi:
5. Di Konsol Google Cloud , buka halaman detail untuk aplikasi Bank of Anthos.
  
  Buka detail Bank of Anthos
  
  Logo ditampilkan di header halaman detail:
Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan dalam tutorial ini, hapus project Google Cloud yang Anda buat untuk tutorial ini.

Menghapus project
1. In the Google Cloud console, go to the Manage resources page.
  Go to Manage resources
2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.
Langkah berikutnya
- Pelajari contoh lain file application.yaml di folder Kubernetes dari repositori GitHub click-to-deploy. Cari file application.yaml lainnya di bagian chart/<application>/templates/ untuk berbagai aplikasi—misalnya seperti yang terlihat dalam file ini.
- Gunakan Deployment Marketplace untuk solusi Click-to-Deploy Google untuk GKE.
- Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.

Menggunakan halaman Applications GKE di konsol Google Cloud Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Tujuan

Biaya

Sebelum memulai

Menyiapkan lingkungan Anda

Menginstal aplikasi contoh

Menyiapkan GKE

Mencantumkan resource aplikasi

Membuat resource dasar Aplikasi

Mencantumkan resource berdasarkan komponen

Memfilter resource dengan pemilih

Menerapkan label ke semua resource dengan kustomize

Menambahkan metadata berguna di tampilan

Menambahkan deskripsi dan dokumentasi

Mencantumkan jenis software

Mencantumkan versi aplikasi

Menambahkan detail pengelola

Mengekspos endpoint aplikasi

Memberikan kredensial akses

Menambahkan ikon aplikasi

Pembersihan

Menghapus project

Langkah berikutnya

Menggunakan halaman Applications GKE di konsol Google Cloud

Menerapkan label ke semua resource dengan `kustomize`