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 mengubah kode (di sini adalah aplikasi ASP.NET Core Hello World sederhana) menjadi aplikasi yang direplikasi dan 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 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.

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

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

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 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. Guna 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 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 dimuat 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.

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

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 buat gambar:

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 dibuat:

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

Manfaatkan lagi fitur Pratinjau web Cloud Shell :

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 seperti yang diharapkan, 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) :

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

Jika penasaran, Anda dapat menjelajahi image penampung 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, Anda sekarang siap membuat cluster GKE, tetapi sebelum itu, buka bagian Google Kubernetes Engine di konsol web dan tunggu hingga sistem diinisialisasi (hanya memerlukan waktu 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 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

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 selanjutnya dari 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 terikat bersama untuk tujuan administrasi dan jaringan. Cluster ini dapat berisi satu atau beberapa penampung. Di sini, Anda cukup menggunakan satu container yang dibangun dengan image ASP.NET Core yang disimpan di registry container pribadi Anda. Server ini akan menyajikan konten di port 8080.

Buat file hello-dotnet.yaml menggunakan editor favorit Anda (vim, nano,emacs atau editor kode 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 Anda lihat, 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 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, jalankan perintah ini:

kubectl get pods

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

Sekarang adalah waktu 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 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-dotnet --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         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 load-balanced eksternal. Dalam contoh ini, alamat IP eksternal adalah 104.155.20.69.

EXTERNAL-IP mungkin memerlukan waktu beberapa menit untuk tersedia dan terlihat. Jika EXTERNAL-IP tidak ada, tunggu beberapa menit dan coba lagi.

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 beralih ke container dan Kubernetes - Anda tidak perlu menentukan host mana yang akan menjalankan workload, dan Anda juga mendapatkan manfaat dari pemantauan dan memulai ulang layanan. Mari kita lihat apa lagi yang bisa Anda dapatkan 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 lebih banyak kapasitas untuk aplikasi; Anda cukup memberi tahu replication controller untuk mengelola sejumlah 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 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.

Berikut diagram yang merangkum status cluster Kubernetes Anda:

Anda juga dapat menurunkan 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 saat, 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 dan 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 

Lalu, ubah menjadi:

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 

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-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 akan menggunakan perintah kubectl edit. Tindakan ini akan membuka editor teks yang menampilkan konfigurasi yaml deployment lengkap. Anda tidak perlu memahami konfigurasi yaml sepenuhnya saat ini, cukup pahami bahwa dengan memperbarui 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 (ini menggunakan vi, jadi tekan "Esc", lalu ketik :wq, lalu tekan tombol "Enter").

deployment "hello-dotnet" edited

Tindakan ini akan mengupdate 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 aplikasi versi baru Anda.

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

Semoga dengan fitur deployment, penskalaan, dan update ini, Anda akan setuju bahwa setelah menyiapkan 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 perlu 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!

Ini mengakhiri codelab memulai sederhana ini 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 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 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 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.