Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Men-deploy aplikasi ASP.NET Core ke Kubernetes di Google Kubernetes Engine

1. Ringkasan

ASP.NET Core adalah framework open source dan lintas platform baru untuk membangun aplikasi berbasis cloud dan terhubung ke internet modern menggunakan bahasa pemrograman C#.

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 aplikasi ASP.NET Core sederhana ke Kubernetes yang berjalan di Kubernetes Engine. Codelab ini dibuat berdasarkan codelab Membangun dan meluncurkan aplikasi ASP.NET Core dari Google Cloud Shell. Sebaiknya selesaikan lab tersebut terlebih dahulu sebelum mencoba lab ini.

Tujuan codelab ini adalah agar Anda dapat mengubah kode (aplikasi ASP.NET Core Halo Dunia sederhana di sini) menjadi aplikasi replika yang berjalan di Kubernetes. Anda mengambil kode yang telah dikembangkan di komputer, mengubahnya menjadi image container Docker, lalu menjalankan image tersebut di Google Kubernetes Engine.

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

Untuk tujuan codelab ini, dengan menggunakan lingkungan terkelola seperti Kubernetes Engine (versi Kubernetes yang dihosting oleh 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.

Yang akan Anda pelajari

Cara mengemas aplikasi ASP.NET Core sederhana sebagai container Docker.
Cara membuat cluster Kubernetes di Google Kubernetes Engine (GKE).
Cara men-deploy aplikasi ASP.NET Core ke pod.
Cara mengizinkan traffic eksternal ke pod Anda.
Cara meningkatkan skala layanan dan meluncurkan upgrade.
Cara menjalankan dasbor Grafis Kubernetes.

Yang Anda butuhkan

Browser, seperti Chrome atau Firefox

Bagaimana Anda akan menggunakan tutorial ini?

Hanya membacanya

Membacanya dan menyelesaikan latihan

Bagaimana penilaian Anda terhadap pengalaman dengan Google Cloud Platform?

Pemula

Menengah

Mahir

2. Penyiapan dan Persyaratan

Penyiapan lingkungan mandiri

Login ke Google Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. Jika belum memiliki akun Gmail atau Google Workspace, Anda harus membuatnya.

Project name adalah nama tampilan untuk peserta project ini. String ini adalah string karakter yang tidak digunakan oleh Google API. Anda dapat memperbaruinya kapan saja.
Project ID harus unik di semua project Google Cloud dan tidak dapat diubah (tidak dapat diubah setelah ditetapkan). Cloud Console otomatis membuat string unik; biasanya Anda tidak mementingkan kata-katanya. Di sebagian besar codelab, Anda harus merujuk Project ID-nya (biasanya diidentifikasi sebagai PROJECT_ID). Jika tidak suka dengan ID yang dibuat, Anda dapat membuat ID acak lainnya. Atau, Anda dapat mencobanya sendiri dan melihat apakah ID tersebut tersedia. ID tidak dapat diubah setelah langkah ini dan akan tetap ada selama durasi project.
Sebagai informasi, ada nilai ketiga, Project Number yang digunakan oleh beberapa API. Pelajari lebih lanjut ketiga nilai ini di dokumentasi.

Selanjutnya, Anda harus mengaktifkan penagihan di Konsol Cloud untuk menggunakan resource/API Cloud. Menjalankan operasi dalam codelab ini seharusnya tidak memerlukan banyak biaya, bahkan mungkin tidak sama sekali. Guna menonaktifkan resource agar tidak menimbulkan penagihan di luar tutorial ini, Anda dapat menghapus resource yang dibuat atau menghapus seluruh project. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.

Mulai Cloud Shell

Meskipun Google Cloud dapat dioperasikan dari jarak jauh menggunakan laptop Anda, dalam codelab ini, Anda akan menggunakan Google Cloud Shell, lingkungan command line yang berjalan di Cloud.

Mengaktifkan Cloud Shell

Dari Cloud Console, klik Aktifkan Cloud Shell .

Jika belum pernah memulai Cloud Shell, Anda akan melihat layar perantara (di paruh bawah) yang menjelaskan apa itu Cloud Shell. Jika demikian, klik Continue (dan Anda tidak akan pernah melihatnya lagi). Berikut tampilan layar sekali-tampil tersebut:

Perlu waktu beberapa saat untuk menyediakan dan terhubung ke Cloud Shell.

Virtual machine ini dilengkapi dengan semua alat pengembangan yang Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Sebagian besar pekerjaan Anda dalam codelab ini dapat dilakukan hanya dengan browser atau Chromebook.

Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda sudah diautentikasi dan project sudah ditetapkan ke project ID Anda.

Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa Anda telah diautentikasi:

gcloud auth list

Output perintah

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa perintah gcloud mengetahui project Anda:

gcloud config list project

Output perintah

[core]
project = <PROJECT_ID>

Jika tidak, Anda dapat menyetelnya dengan perintah ini:

gcloud config set project <PROJECT_ID>

Output perintah

Updated property [core/project].

3. Membuat aplikasi ASP.NET Core di Cloud Shell

Di prompt Cloud Shell, Anda dapat memverifikasi bahwa alat command line dotnet sudah terinstal dengan memeriksa versinya. Perintah ini akan mencetak versi alat command line dotnet yang diinstal:

dotnet --version

Selanjutnya, buat aplikasi web ASP.NET Core skeleton baru.

dotnet new mvc -o HelloWorldAspNetCore

Perintah ini akan membuat project dan memulihkan dependensinya. Anda seharusnya melihat pesan yang mirip seperti di bawah ini.

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. Jalankan aplikasi ASP.NET Core

Aplikasi hampir siap untuk dijalankan. Buka folder aplikasi.

cd HelloWorldAspNetCore

Terakhir, jalankan aplikasi.

dotnet run --urls=http://localhost:8080

Aplikasi mulai memproses di port 8080.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

Untuk memastikan aplikasi sudah berjalan, klik tombol pratinjau web di kanan atas, lalu pilih ‘Pratinjau di port 8080'.

Anda akan melihat halaman web ASP.NET Core default:

Setelah Anda memverifikasi bahwa aplikasi sedang berjalan, tekan Ctrl+C untuk mematikan aplikasi.

5. Mengemas aplikasi ASP.NET Core sebagai container Docker

Selanjutnya, siapkan aplikasi Anda untuk dijalankan sebagai container. Langkah pertama adalah menentukan penampung dan isinya.

Di direktori dasar aplikasi, buat Dockerfile untuk menentukan image Docker.

touch Dockerfile

Tambahkan kode berikut ke Dockerfile menggunakan editor favorit Anda (vim, nano,emacs atau editor kode Cloud Shell).

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

Salah satu konfigurasi penting yang disertakan dalam Dockerfile Anda adalah port tempat aplikasi memproses traffic masuk (8080). Hal ini dilakukan dengan menyetel variabel lingkungan ASPNETCORE_URLS, yang digunakan aplikasi ASP.NET Core untuk menentukan port yang akan dipantau.

Simpan Dockerfile ini. Sekarang, mari kita bangun image:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

Setelah selesai (perlu waktu beberapa saat untuk mendownload dan mengekstrak semuanya), Anda dapat melihat bahwa image telah dibuat dan disimpan secara lokal:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1

Uji image secara lokal dengan perintah berikut yang akan menjalankan container Docker secara lokal di port 8080 dari image container yang baru Anda buat:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Manfaatkan lagi fitur Pratinjau web Cloud Shell :

Screenshot dari 2015-11-03 17:20:22.png

Anda akan melihat halaman web ASP.NET Core default di tab baru.

Setelah memverifikasi bahwa aplikasi berjalan dengan baik secara lokal dalam container Docker, Anda dapat menghentikan container yang sedang berjalan dengan Ctrl-> C.

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

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Jika semuanya berjalan lancar dan setelah beberapa saat, Anda akan dapat melihat image container yang tercantum di bagian Container Registry. Pada tahap ini, Anda memiliki image Docker tingkat project yang dapat diakses dan diorkestrasi oleh Kubernetes seperti yang akan Anda lihat dalam beberapa menit.

Jika penasaran, Anda dapat menjelajahi image container saat disimpan di Google Cloud Storage dengan mengikuti link ini: https://console.cloud.google.com/storage/browser/ (link lengkap yang dihasilkan harus dalam bentuk ini: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Membuat cluster Kubernetes

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

Sebuah cluster terdiri atas satu server API master Kubernetes yang dikelola oleh Google dan sejumlah worker node. Worker node adalah virtual machine Compute Engine.

Mari gunakan CLI gcloud dari sesi CloudShell Anda untuk membuat cluster. Sesuaikan zona Anda ke lokasi yang dekat dengan Anda ( daftar zona). Proses ini akan memerlukan waktu beberapa menit:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

Pada akhirnya, Anda akan melihat cluster yang dibuat.

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

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.

7. Buat deployment

Pod Kubernetes adalah sekelompok container yang dihimpun untuk tujuan administrasi dan jaringan. Pod ini dapat berisi satu atau beberapa container. Di sini, Anda cukup menggunakan satu container yang dibangun dengan image ASP.NET Core yang disimpan di Container Registry pribadi Anda. Container ini akan menyajikan konten di port 8080.

Buat file hello-dotnet.yaml menggunakan editor pilihan Anda (vim, nano,emacs atau editor kode Cloud Shell) dan tentukan Deployment Kubernetes untuk pod:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

Deploy ke namespace default dengan kubectl:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

Seperti yang terlihat, Anda telah membuat objek deployment. Deployment merupakan cara yang direkomendasikan untuk membuat dan menskalakan pod. Di sini, deployment baru mengelola satu replika pod yang menjalankan image hello-dotnet:v1.

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

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

Untuk melihat pod yang dibuat oleh deployment ini, jalankan perintah ini:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

Sekarang adalah saat yang tepat untuk menjalankan beberapa perintah kubectl yang menarik (tidak ada yang akan mengubah status cluster, dokumentasi lengkap tersedia di sini):

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

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

8. Mengizinkan traffic eksternal

Secara default, pod hanya dapat diakses oleh IP internalnya di dalam cluster. Agar container hello-dotnet dapat diakses dari luar jaringan virtual Kubernetes, Anda harus mengekspos pod tersebut sebagai service Kubernetes.

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

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

Flag yang digunakan dalam perintah ini menentukan bahwa Anda akan menggunakan load balancer yang disediakan oleh infrastruktur dasar (dalam hal ini load balancer Compute Engine). Perhatikan bahwa yang Anda ekspos secara langsung adalah deployment, bukan pod. Akibatnya, service yang dihasilkan akan melakukan load balancing traffic di semua pod yang dikelola oleh deployment itu (dalam hal ini hanya 1 pod, tetapi Anda akan menambahkan lebih banyak replika nanti).

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

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

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

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 eksternal dengan load balancing. Dalam contoh ini, alamat IP eksternal adalah 104.155.20.69.

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

Pada tahap ini, Anda telah mendapatkan setidaknya beberapa fitur dari proses migrasi ke container dan Kubernetes. Anda tidak perlu menentukan host tempat workload Anda akan berjalan. Selain itu, Anda juga mendapatkan manfaat dari pemantauan dan restart service. Sekarang, lihat apa saja yang bisa didapatkan dari infrastruktur Kubernetes baru Anda.

9. 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; Anda cukup meminta pengontrol replikasi mengelola jumlah replika baru untuk pod Anda:

kubectl scale deployment hello-dotnet --replicas=4

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

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

Perhatikan pendekatan deklaratif di sini - alih-alih memulai atau menghentikan instance baru, Anda mendeklarasikan jumlah instance yang harus berjalan setiap saat. Loop rekonsiliasi Kubernetes hanya memastikan bahwa kondisi aktual sesuai dengan yang Anda minta dan tindakan diambil jika diperlukan.

Berikut diagram yang meringkas status cluster Kubernetes Anda:

Anda juga dapat memperkecil skala layanan dengan sangat mudah. Berikut cara memperkecil skala dari 4 pod menjadi 2 pod.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. Ketahanan Pengujian

Kubernetes (atau lebih tepatnya ReplicaSet) memantau pod Anda dan jika ada yang salah dengan pod dan pod tersebut tidak berfungsi, Kubernetes akan segera membuat pod baru. Mari kita coba dan lihat cara kerjanya.

Pertama, dapatkan daftar pod:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

Hapus salah satu pod dengan meneruskan nama pod:

kubectl delete pod hello-dotnet-714049816-g4azy

Jika melihat daftar pod lagi, Anda akan melihat pod baru dibuat dan berjalan lagi dengan segera:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. Meluncurkan upgrade ke layanan Anda

Pada suatu titik, aplikasi yang telah Anda deploy ke produksi akan memerlukan perbaikan bug atau fitur tambahan. Mari kita lihat seperti apa prosesnya.

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

Buka Index.cshtml di bagian HelloWorldAspNetCore > Views > Home, lalu perbarui salah satu pesan carousel.

Temukan baris berikut:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core

Dan ubah menjadi seperti ini:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

Simpan perubahan, lalu kembali ke Cloud Shell. Di dalam HelloWorldAspNetCore,, bangun image Docker:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .

Lalu, kirim ke Container Registry:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2

Sekarang Anda siap agar Kubernetes mengupdate pengontrol replikasi Anda ke versi baru aplikasi dengan lancar. Agar dapat mengubah label image untuk container yang sedang berjalan, Anda perlu mengedit hello-dotnet deployment yang ada dan mengubah image dari gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 menjadi gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.

Untuk melakukannya, Anda akan menggunakan perintah kubectl edit. Tindakan ini akan membuka editor teks yang menampilkan konfigurasi yaml deployment lengkap. Anda tidak perlu memahami konfigurasi yaml lengkap saat ini. Cukup pahami bahwa dengan memperbarui kolom spec.template.spec.containers.image dalam konfigurasi tersebut, Anda meminta deployment agar mengupdate pod untuk menggunakan image baru.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Setelah melakukan perubahan, simpan dan tutup file (ini menggunakan vi, jadi tekan "Esc", lalu ketik :wq, lalu tekan tombol "Enter").

deployment "hello-dotnet" edited

Tindakan ini akan memperbarui deployment dengan image baru, sehingga pod baru dibuat dengan image baru dan pod lama dihapus.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

Selama proses ini berlangsung, pengguna layanan tidak akan mengalami gangguan. Setelah beberapa saat, mereka akan mulai mengakses versi baru aplikasi Anda.

Anda dapat menemukan detail selengkapnya tentang update bertahap di dokumentasi Kubernetes.

Semoga dengan fitur deployment, penskalaan, dan pembaruan ini, Anda akan setuju bahwa setelah menyelesaikan penyiapan lingkungan (cluster GKE/Kubernetes di sini), Kubernetes dapat membantu Anda berfokus pada aplikasi, bukan mengelola infrastruktur.

12. Cloud Build

Sejauh ini, kita telah membangun container dengan perintah Docker biasa (docker build ...), lalu mengirim image secara manual ke Container Registry Google Cloud Platform. Anda juga dapat menunda kedua langkah ke sisi server Cloud Build, yang dapat membangun dan mengirim image container tanpa harus menginstal Docker secara lokal.

Pertama, aktifkan Cloud Build API di API Manager > Library. Telusuri Cloud Build, klik Cloud Build API:

Klik Enable API, jika belum diaktifkan. Pada akhirnya, Anda akan melihat API diaktifkan seperti berikut:

Setelah Cloud Build API diaktifkan, Anda dapat menjalankan perintah berikut untuk membangun dan mengirimkan image dari layanan Container Builder:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

Image otomatis disimpan di Container Registry.

13. Menjalankan dasbor Grafis Kubernetes

Dengan Kubernetes versi terbaru, antarmuka pengguna web grafis (dasbor) telah diperkenalkan. Antarmuka pengguna ini memungkinkan Anda memulai dengan cepat dan mengaktifkan beberapa fungsi yang ada di CLI sebagai cara yang lebih mudah diakses dan ditemukan untuk berinteraksi dengan sistem.

Untuk mengonfigurasi akses ke dasbor cluster Kubernetes, dari jendela Cloud Shell, ketik perintah berikut :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

Kemudian, gunakan fitur pratinjau Cloud Shell sekali lagi untuk membuka port 8081:

Tindakan ini akan mengarahkan Anda ke endpoint API. Anda mungkin melihat halaman "Tidak sah", tetapi jangan khawatir. Untuk membuka dasbor, hapus "?authuser=3" dan ganti dengan "/ui".

Nikmati dasbor grafis Kubernetes dan gunakan untuk men-deploy aplikasi dalam container, serta untuk memantau dan mengelola cluster Anda.

Atau, Anda dapat mengakses dasbor dari komputer lokal atau pengembangan menggunakan petunjuk serupa yang diberikan saat, dari Konsol web, Anda menekan tombol "Hubungkan" untuk cluster yang ingin dipantau.

Setelah selesai menggunakan dasbor, Anda dapat menekan Control + C untuk menghentikan proxy. Pelajari dasbor Kubernetes lebih lanjut dengan mengikuti Tur dasbor.

14. Logging

Anda dapat menggunakan perintah kubectl logs untuk mengambil log container yang berjalan di dalam Kubernetes. Saat Anda menggunakan Google Kubernetes Engine untuk menjalankan cluster Kubernetes terkelola, semua log akan otomatis diteruskan dan disimpan di Google Cloud Logging. Anda dapat melihat semua output log dari pod dengan membuka Stackdriver → Logging → Logs di konsol Google Cloud:

Setelah berada di konsol logging, Anda dapat membuka GKE Container untuk melihat semua log yang dikumpulkan dari STDOUT:

Dari sini, Anda dapat secara opsional mengekspor log ke Google BigQuery untuk analisis log lebih lanjut, atau menyiapkan pemberitahuan berbasis log. Kita tidak akan melakukannya selama lab hari ini.

15. Selamat!

Dengan demikian, codelab memulai sederhana ini dengan ASP.NET Core dan Kubernetes telah selesai. Kita baru saja mempelajari bagian awal teknologi ini. Sebaiknya Anda mempelajari lebih jauh menggunakan pod, pengontrol replikasi, dan layanan Anda sendiri, serta lihat juga pemeriksaan keaktifan (health check), dan pertimbangkan untuk menggunakan Kubernetes API secara langsung.

Pembersihan

Selesai! Saatnya membersihkan resource yang digunakan (untuk menghemat biaya dan menjadi pengguna cloud yang baik).

Hapus Deployment (yang juga menghapus pod yang sedang berjalan) dan Service (yang juga menghapus load balancer eksternal Anda):

Pertama, hapus layanan dan deployment, yang juga menghapus load balancer eksternal Anda:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

Selanjutnya, hapus cluster Anda:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

Tindakan ini akan menghapus semua instance Google Compute Engine yang menjalankan cluster.

Terakhir, hapus bucket penyimpanan Docker registry yang menghosting image Anda:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Tentu saja, Anda juga dapat menghapus seluruh project, tetapi Anda akan kehilangan semua konfigurasi penagihan yang telah Anda lakukan (penonaktifan penagihan project diperlukan terlebih dahulu). Selain itu, penghapusan project hanya akan menghentikan semua penagihan setelah siklus penagihan saat ini berakhir.

Yang telah kita bahas

Cara mengemas aplikasi ASP.NET Core sederhana sebagai container Docker.
Cara membuat cluster Kubernetes di Google Kubernetes Engine.
Cara men-deploy aplikasi ASP.NET Core ke pod.
Cara mengizinkan traffic eksternal ke pod Anda.
Cara meningkatkan skala layanan dan meluncurkan upgrade.
Cara menjalankan dasbor Grafis Kubernetes.

Langkah Berikutnya

Pelajari Kubernetes lebih lanjut ( http://kubernetes.io/).
Pelajari lebih lanjut Windows di Google Cloud Platform.
Pelajari lebih lanjut .NET di Google Cloud Platform.
Pelajari lebih lanjut SQL Server di Google Cloud Platform.
Pelajari lebih lanjut Cloud Tools for Visual Studio.
Pelajari lebih lanjut Cloud Tools for PowerShell.

Lisensi

Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.