Men-deploy aplikasi ke cluster GKE

Men-deploy aplikasi ke cluster GKE

Autopilot Standard

---

Dalam panduan memulai ini, Anda akan men-deploy aplikasi dalam container server web contoh ke cluster Google Kubernetes Engine (GKE). Anda akan mempelajari cara membuat cluster, dan cara men-deploy aplikasi ke cluster sehingga dapat diakses oleh pengguna.

Halaman ini ditujukan bagi Operator dan Developer yang menyediakan dan mengonfigurasi resource cloud serta men-deploy aplikasi dan layanan. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten Google Cloud, lihat Peran dan tugas pengguna GKE Enterprise umum.

Sebelum membaca halaman ini, pastikan Anda sudah memahami Kubernetes.

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Kubernetes Engine API:

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   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

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   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

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

Meluncurkan Cloud Shell

Dalam tutorial ini, Anda akan menggunakan Cloud Shell, yang merupakan lingkungan shell untuk mengelola resource yang dihosting diGoogle Cloud.

Cloud Shell telah diinstal dengan alat command line Google Cloud CLI dan kubectl. Gcloud CLI menyediakan antarmuka command line utama untuk Google Cloud, dan kubectl menyediakan antarmuka command line utama untuk menjalankan perintah terhadap cluster Kubernetes.

Meluncurkan Cloud Shell:

1. Buka Google Cloud konsol.

   Google Cloud console

2. Dari pojok kanan atas konsol, klik tombol Activate Cloud Shell:

Sesi Cloud Shell akan terbuka di dalam frame yang lebih rendah di konsol. Anda menggunakan shell ini untuk menjalankan perintah gcloud dan kubectl. Sebelum menjalankan perintah, tetapkan project default Anda di Google Cloud CLI menggunakan perintah berikut:

gcloud config set project PROJECT_ID

Ganti PROJECT_ID dengan project ID Anda.

Membuat cluster GKE

Cluster terdiri dari setidaknya satu mesin bidang kontrol cluster dan beberapa mesin pekerja yang disebut node. Node adalah instance virtual machine (VM) Compute Engine yang menjalankan proses Kubernetes yang diperlukan untuk menjadikannya bagian dari cluster. Anda men-deploy aplikasi ke cluster, kemudian aplikasi akan berjalan di node.

Buat cluster Autopilot bernama hello-cluster:

gcloud container clusters create-auto hello-cluster \
    --location=us-central1

Catatan: Mungkin perlu waktu beberapa menit untuk menyelesaikan pembuatan cluster.

Mendapatkan kredensial autentikasi untuk cluster

Setelah membuat cluster, Anda perlu mendapatkan kredensial autentikasi agar dapat berinteraksi dengan cluster:

gcloud container clusters get-credentials hello-cluster \
    --location us-central1

Perintah ini mengonfigurasi kubectl untuk menggunakan cluster yang Anda buat.

Men-deploy aplikasi ke cluster

Setelah membuat cluster, Anda dapat men-deploy aplikasi dalam kontainer ke cluster tersebut. Untuk panduan memulai ini, Anda dapat men-deploy aplikasi web contoh kami, hello-app.

GKE menggunakan objek Kubernetes untuk membuat dan mengelola resource cluster Anda. Kubernetes menyediakan objek Deployment untuk men-deploy aplikasi stateless seperti server web. Objek layanan menentukan aturan dan load balancing untuk mengakses aplikasi Anda dari internet.

Membuat Deployment

Untuk menjalankan hello-app di cluster, Anda harus men-deploy aplikasi dengan menjalankan perintah berikut:

kubectl create deployment hello-server \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Perintah Kubernetes ini, kubectl create deployment, membuat Deployment yang bernama hello-server. Pod Deployment akan menjalankan image container hello-app.

Dalam perintah ini:

• --image menentukan image container yang akan di-deploy. Dalam hal ini, perintah tersebut akan mengambil image contoh dari repositori Artifact Registry, us-docker.pkg.dev/google-samples/containers/gke/hello-app. :1.0 menunjukkan versi image tertentu yang akan ditarik. Jika Anda tidak menentukan versinya, image dengan tag latest default akan digunakan.

Mengekspos Deployment

Setelah men-deploy aplikasi, Anda perlu mengeksposnya ke internet agar pengguna dapat mengaksesnya. Anda dapat mengekspos aplikasi Anda dengan membuat Service, yaitu resource Kubernetes yang mengekspos aplikasi Anda ke traffic eksternal.

Untuk mengekspos aplikasi Anda, jalankan perintah kubectl expose berikut:

kubectl expose deployment hello-server \
    --type LoadBalancer \
    --port 80 \
    --target-port 8080

Meneruskan flag --type LoadBalancer akan membuat load balancer Compute Engine untuk container Anda. Flag --port menginisialisasi port publik 80 ke internet dan flag --target-port mengarahkan traffic ke port 8080 aplikasi.

Load balancer ditagih per harga load balancer Compute Engine.

Memeriksa dan melihat aplikasi

1. Periksa Pod yang berjalan menggunakan kubectl get pods:

   kubectl get pods
   

   Anda akan melihat satu Pod hello-server berjalan di cluster Anda.

2. Periksa Layanan hello-server menggunakan kubectl get service:

   kubectl get service hello-server
   

   Dari output perintah ini, salin alamat IP eksternal Layanan dari kolom EXTERNAL-IP.

   Catatan: Anda mungkin perlu menunggu beberapa menit sebelum alamat IP eksternal Layanan terisi. Jika IP eksternal aplikasi adalah <pending>, jalankan kubectl get lagi.

3. Lihat aplikasi dari browser web dengan menggunakan alamat IP eksternal dengan port yang diekspos:

   http://EXTERNAL_IP
   

Anda baru saja berhasil men-deploy aplikasi web dalam container ke GKE.

Untuk melacak dan mengatur resource GKE dengan cara yang berfokus pada aplikasi, Anda dapat menambahkan resource sebagai Layanan dan workload ke aplikasi App Hub.

Untuk mengetahui informasi selengkapnya tentang resource yang didukung App Hub, lihat Resource yang didukung.

Untuk mempelajari cara menyiapkan App Hub di project Anda, lihat Menyiapkan App Hub.

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan di halaman ini, ikuti langkah-langkah berikut.

1. Hapus Layanan aplikasi dengan menjalankan kubectl delete:

   kubectl delete service hello-server
   

   Perintah ini menghapus load balancer Compute Engine yang Anda buat saat mengekspos Deployment.

2. Hapus cluster Anda dengan menjalankan gcloud container clusters delete:

   gcloud container clusters delete hello-cluster \
       --location us-central1
   

Opsional: peninjauan kode hello-app

hello-app adalah aplikasi server web yang terdiri dari dua file: main.go dan Dockerfile.

hello-app dikemas sebagai image container Docker. Image container disimpan di registry image Docker apa pun, seperti Artifact Registry. Kami menghosting hello-app dalam repositori Artifact Registry di us-docker.pkg.dev/google-samples/containers/gke/hello-app.

main.go

main.go adalah implementasi server web yang ditulis dalam bahasa pemrograman Go. Server merespons permintaan HTTP apa pun dengan pesan "Hello, world!"

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Dockerfile

Dockerfile mendeskripsikan image yang Anda inginkan untuk dibuat oleh Docker, termasuk semua resource dan dependensinya, dan menentukan port jaringan yang harus ditampakkan oleh aplikasi. Untuk mengetahui informasi selengkapnya tentang cara kerja file ini, lihat referensi Dockerfile dalam dokumentasi Docker.

FROM golang:1.23.2 as builder
WORKDIR /app
RUN go mod init hello-app
COPY *.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -o /hello-app

FROM gcr.io/distroless/base-debian11
WORKDIR /
COPY --from=builder /hello-app /hello-app
ENV PORT 8080
USER nonroot:nonroot
CMD ["/hello-app"]

Langkah berikutnya

• Pelajari lebih lanjut tentang membuat cluster.
• Pelajari Kubernetes lebih lanjut.
• Pelajari cara memaketkan, menghosting, dan men-deploy aplikasi server web sederhana.
• Deploy aplikasi Kubernetes dengan Cloud Code untuk VS Code atau Cloud Code untuk IntelliJ.
• Pelajari cara Membuat platform ulang aplikasi Linux ke container.

Coba sendiri

Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa GKE dalam skenario dunia nyata. Pelanggan baru mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Coba GKE gratis