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 modern berbasis cloud dan terhubung internet menggunakan bahasa pemrograman C#.

Kubernetes adalah project open source yang dapat berjalan di berbagai lingkungan, dari laptop hingga cluster multinode dengan ketersediaan tinggi, dari cloud publik hingga deployment lokal, 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 lakukan lab tersebut terlebih dahulu sebelum mencoba lab ini.

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

Berikut adalah diagram berbagai bagian yang berfungsi dalam codelab ini untuk membantu Anda memahami cara kerja berbagai bagian. Gunakan ini sebagai referensi saat Anda melanjutkan codelab; semuanya sudah masuk akal pada saat Anda sampai ke akhir (tapi untuk saat ini Anda jangan ragu untuk mengabaikannya).

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

Jika tertarik untuk menjalankan Kubernetes di komputer lokal, seperti laptop pengembangan, Anda mungkin perlu mempelajari Minikube. Fungsi ini menawarkan penyiapan sederhana dari cluster kubernetes node tunggal untuk tujuan pengembangan dan pengujian. Anda dapat menggunakan Minikube untuk membuka codelab ini jika mau.

Yang akan Anda pelajari

• Cara memaketkan 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

1. 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 peduli tentang apa itu. Di sebagian besar codelab, Anda harus mereferensikan Project ID (biasanya diidentifikasi sebagai PROJECT_ID). Jika Anda tidak menyukai ID yang dihasilkan, Anda dapat membuat ID acak lainnya. Atau, Anda dapat mencobanya sendiri dan lihat 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.

Perhatian: Project ID harus bersifat unik secara global dan tidak dapat digunakan orang lain setelah Anda memilihnya. Anda adalah satu-satunya pengguna ID tersebut. Meskipun project sudah dihapus, ID tersebut tidak akan dapat digunakan lagi

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

2. 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. Untuk mematikan 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

1. 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 Lanjutkan (dan Anda tidak akan pernah melihatnya lagi). Berikut tampilan layar sekali-tampil tersebut:

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

Mesin virtual ini dimuat dengan semua alat pengembangan yang Anda butuhkan. 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.

2. 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`

Catatan: Alat command-line gcloud adalah alat command-line yang canggih dan terpadu di Google Cloud. Alat ini sudah diinstal lebih dulu di Cloud Shell. Anda akan melihat dukungannya untuk penyelesaian tab. Untuk mengetahui informasi selengkapnya, baca ringkasan alat command line gcloud.

3. 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

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

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. Menjalankan 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 'Preview on port 8080'.

Anda akan melihat halaman web ASP.NET Core default:

Setelah Anda memverifikasi bahwa aplikasi 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 kontennya.

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 untuk mendownload dan mengekstrak semuanya), Anda dapat melihat bahwa image 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 dibuat:

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

Sekali lagi, manfaatkan fitur pratinjau Web CloudShell :

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

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

Setelah image berfungsi sebagaimana mestinya, Anda dapat mengirimkannya ke Google Container Registry, yakni 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 sekarang memiliki image Docker di seluruh project yang dapat diakses dan diorkestrasi oleh Kubernetes seperti yang akan Anda lihat dalam beberapa menit.

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

Jika ingin tahu, Anda dapat membuka image container yang tersimpan di Google Cloud Storage dengan mengikuti link ini: https://console.cloud.google.com/storage/browser/ (link lengkap yang dihasilkan seharusnya dalam bentuk ini: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Membuat cluster Kubernetes

Baiklah. Anda sekarang siap untuk membuat cluster GKE, tetapi sebelum itu, buka bagian Google Kubernetes Engine pada konsol web dan tunggu hingga sistem melakukan inisialisasi (proses ini hanya memerlukan waktu beberapa detik).

Cluster terdiri atas server API master Kubernetes yang dikelola oleh Google dan sekumpulan node pekerja. Worker node adalah virtual machine Compute Engine.

Mari kita gunakan CLI gcloud dari sesi CloudShell Anda untuk membuat cluster. Sesuaikan zona ke tempat 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

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

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

Sekarang Anda 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 (sudah disiapkan di lingkungan Cloud Shell Anda). Bagian lainnya dari codelab ini mengharuskan versi klien dan server kubernetes 1.2 atau yang lebih baru. kubectl version akan menunjukkan versi perintah saat ini.

7. Buat deployment

pod kubernetes adalah sekumpulan container yang disatukan untuk keperluan administrasi dan jaringan. Dapat berisi satu atau beberapa penampung. Di sini, Anda hanya perlu menggunakan satu container yang dibuat dengan image ASP.NET Core yang disimpan di container registry pribadi Anda. URL ini akan menyalurkan konten di port 8080.

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

Pastikan Anda mengganti YOUR-PROJECT-ID dengan ID project Anda

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 dapat dilihat, Anda telah membuat objek deployment. Deployment adalah 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 dibuat, 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, 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 satu pun yang akan mengubah status cluster, dokumentasi lengkapnya tersedia di sini):

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

Pada tahap ini, container Anda seharusnya berjalan di bawah kendali Kubernetes, tetapi Anda masih harus membuatnya dapat diakses oleh dunia luar.

8. Izinkan 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 sebagai layanan kubernetes.

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

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

Tanda 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 Anda mengekspos deployment, bukan pod secara langsung. Hal ini akan menyebabkan layanan yang dihasilkan melakukan load balancing terhadap 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 Compute Engine, kumpulan target, dan aturan firewall terkait agar layanan dapat diakses sepenuhnya dari luar Google Cloud Platform.

Untuk menemukan alamat IP layanan yang dapat diakses publik, cukup minta kubectl untuk mencantumkan semua layanan 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

Perlu diperhatikan bahwa ada 2 alamat IP yang tercantum untuk layanan Anda, keduanya adalah port yang melayani 8080. Salah satunya adalah IP internal yang hanya terlihat di dalam jaringan virtual cloud Anda; satu lagi adalah IP eksternal dengan {i>load balanced<i}. Dalam contoh ini, alamat IP eksternalnya adalah 104.155.20.69.

Mungkin perlu waktu beberapa menit hingga EXTERNAL-IP tersedia dan terlihat. Jika EXTERNAL-IP tidak ada, tunggu beberapa menit dan coba lagi.

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

Pada tahap ini, Anda telah memperoleh setidaknya beberapa fitur dari pemindahan ke container dan Kubernetes. Anda tidak perlu menentukan host mana yang akan digunakan untuk menjalankan workload. Anda juga akan mendapatkan manfaat dari pemantauan dan mulai ulang layanan. Mari kita lihat hal lain yang dapat Anda peroleh dari infrastruktur Kubernetes baru Anda.

9. Meningkatkan skala layanan Anda

Salah satu fitur canggih yang ditawarkan oleh Kubernetes adalah kemudahan untuk menskalakan aplikasi Anda. Misalkan tiba-tiba Anda memerlukan lebih banyak kapasitas untuk aplikasi Anda; Anda cukup memberi tahu pengontrol replikasi untuk 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 - daripada memulai atau menghentikan instance baru, Anda harus mendeklarasikan berapa banyak instance yang harus berjalan sepanjang waktu. Loop rekonsiliasi Kubernetes hanya memastikan bahwa realitas sesuai dengan yang Anda minta dan mengambil tindakan jika diperlukan.

Berikut adalah diagram yang meringkas status cluster Kubernetes Anda:

Anda juga bisa memperkecil skala layanan Anda 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. Uji Ketahanan

Kubernetes (atau lebih khusus lagi ReplicaSet) mengawasi pod Anda dan jika ada masalah pada pod lalu terhenti, pod baru akan langsung dibuat. Mari kita uji ini dan lihat cara kerjanya.

Pertama-tama, 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 kembali daftar pod, Anda akan melihat pod baru yang sedang dibuat dan langsung berjalan kembali:

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 titik tertentu, aplikasi yang telah Anda deploy ke produksi akan memerlukan perbaikan bug atau fitur tambahan. Mari kita lihat bagaimana proses itu terlihat.

Pertama, mari kita ubah aplikasinya. Buka editor kode dari Cloud Shell.

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

Cari baris berikut:

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

Dan ubah menjadi 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,build gambar Docker:

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

Dan kirim ke Container Registry:

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

Membangun dan mengirim image yang diupdate ini akan berjalan lebih cepat karena kami memanfaatkan penyimpanan cache sepenuhnya.

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

Untuk melakukannya, Anda harus menggunakan perintah kubectl edit. Tindakan ini akan membuka editor teks yang menampilkan konfigurasi yaml deployment penuh. Anda tidak perlu memahami konfigurasi yaml lengkap sekarang. Cukup pahami bahwa dengan mengupdate kolom spec.template.spec.containers.image dalam konfigurasi, Anda memberi tahu deployment untuk mengupdate pod agar 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 (tindakan ini menggunakan vi, jadi tekan "Esc", lalu ketik :wq dan tekan tombol "Enter").

deployment "hello-dotnet" edited

Tindakan ini akan mengupdate deployment dengan image baru, sehingga menyebabkan 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 hal ini terjadi, pengguna layanan tidak akan mengalami gangguan. Setelah beberapa saat, mereka akan mulai mengakses versi baru aplikasi Anda.

Anda dapat menemukan detail selengkapnya tentang update berkelanjutan dalam dokumentasi Kubernetes.

Semoga dengan fitur deployment, penskalaan, dan update ini, Anda setuju bahwa setelah menyiapkan lingkungan (cluster GKE/Kubernetes di sini), Kubernetes dapat membantu Anda berfokus pada aplikasi, bukan pada pengelolaan infrastruktur.

12. Cloud Build

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

Pertama, aktifkan Cloud Build API di API Manager > Koleksi. 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 mengirim image Anda dari layanan Container Builder:

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

Image disimpan secara otomatis di Container Registry.

13. Menjalankan dasbor Grafis Kubernetes

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

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

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:

Anda akan diarahkan ke endpoint API. Anda mungkin akan mendapatkan pesan "Tidak sah" namun 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.

Selain itu, Anda dapat mengakses dasbor dari mesin pengembangan atau mesin lokal dengan menggunakan petunjuk serupa yang diberikan saat, dari konsol Web, Anda menekan tombol "Hubungkan" untuk cluster yang ingin Anda pantau.

Setelah selesai menggunakan dasbor, Anda dapat 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 → Log di Konsol Google Cloud:

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

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

15. Selamat!

Bagian ini mengakhiri codelab sederhana tentang memulai dengan ASP.NET Core dan Kubernetes. 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 cloud citizen yang baik).

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

Pertama, hapus layanan dan deployment. Tindakan ini juga akan 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 registry Docker yang menghosting gambar 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 penyiapan penagihan yang telah dilakukan (perlu menonaktifkan penagihan project terlebih dahulu). Selain itu, menghapus project hanya akan menghentikan semua penagihan setelah siklus penagihan saat ini berakhir.

Yang telah kita bahas

• Cara memaketkan 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 .NET di Google Cloud Platform lebih lanjut.
• Pelajari SQL Server di Google Cloud Platform lebih lanjut.
• Pelajari Cloud Tools for Visual Studio lebih lanjut.
• Pelajari Cloud Tools for PowerShell lebih lanjut.

Lisensi

Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.