Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy aplikasi dalam image container ke cluster GKE

Autopilot Standar

Halaman ini menunjukkan cara melakukan hal berikut:

Membuat aplikasi Halo Dunia.
Memaketkan aplikasi ke dalam image container menggunakan Cloud Build.
Membuat cluster di Google Kubernetes Engine (GKE).
Men-deploy image container ke cluster Anda.

Contoh ini ditampilkan dalam beberapa bahasa, tetapi Anda dapat menggunakan bahasa lain selain yang ditampilkan.

Untuk mengikuti panduan langkah demi langkah tugas ini langsung di Cloud Shell Editor, klik Pandu saya:

Sebelum memulai

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.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

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

Aktifkan API Artifact Registry, Cloud Build, and Google Kubernetes Engine.

Mengaktifkan API

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

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

Aktifkan API Artifact Registry, Cloud Build, and Google Kubernetes Engine.

Mengaktifkan API

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

kubectl digunakan untuk mengelola Kubernetes, sistem orkestrasi cluster yang digunakan GKE. Anda dapat menginstal kubectl menggunakan gcloud:
```
gcloud components install kubectl
```

Menulis aplikasi contoh

Untuk petunjuk mengenai pembuatan aplikasi Halo Dunia yang berjalan di GKE, klik bahasa Anda:

Go

Buat direktori baru bernama helloworld-gke, lalu pindahlah ke direktori tersebut:
```
mkdir helloworld-gke
cd helloworld-gke
```
Buat modul baru bernama example.com/helloworld:
```
go mod init example.com/helloworld
```

Buat file baru bernama helloworld.go dan tempelkan kode berikut ke dalamnya:

package main

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

func main() {
	http.HandleFunc("/", handler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("Listening on localhost:%s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	log.Print("Hello world received a request.")
	target := os.Getenv("TARGET")
	if target == "" {
		target = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", target)
}

Kode ini menghasilkan server web yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dipaketkan dalam container Docker, lalu diupload ke Artifact Registry.

Node.js

Buat direktori baru bernama helloworld-gke dan pindahlah ke direktori ini:
```
mkdir helloworld-gke
cd helloworld-gke
```

Buat file package.json dengan konten berikut:

{
  "name": "gke-helloworld",
  "version": "1.0.0",
  "description": "GKE hello world sample in Node",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.16.4"
  }
}

Dalam direktori yang sama, buat file index.js, lalu salin baris berikut ke dalamnya:

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  console.log('Hello world received a request.');

  const target = process.env.TARGET || 'World';
  res.send(`Hello ${target}!`);
});

const port = process.env.PORT || 8080;
app.listen(port, () => {
  console.log('Hello world listening on port', port);
});

Kode ini menghasilkan server web yang memantau port yang ditentukan oleh variabel lingkungan PORT.

Aplikasi Anda sudah jadi dan siap dikemas dalam container Docker dan diupload ke Artifact Registry.

Python

Buat direktori baru bernama helloworld-gke dan pindahlah ke direktori ini:
```
mkdir helloworld-gke
cd helloworld-gke
```

Buat file bernama app.py dan tempelkan kode berikut ke dalamnya:

import os

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    target = os.environ.get('TARGET', 'World')
    return 'Hello {}!\n'.format(target)

if __name__ == "__main__":
    app.run(debug=True,host='0.0.0.0',port=int(os.environ.get('PORT', 8080)))

C#

Instal .NET SDK. .NET SDK hanya diperlukan untuk membuat project web baru pada langkah berikutnya. Dockerfile, yang akan dijelaskan nanti, memuat semua dependensi ke dalam container.
Dari terminal Anda, buat project web kosong baru:
```
dotnet new web -o helloworld-gke
```
Ubah direktori ke helloworld-gke.
```
cd helloworld-gke
```

Update Program.cs untuk mendengarkan port 8080:

var builder = WebApplication.CreateBuilder(args);

// Google Cloud Run sets the PORT environment variable to tell this
// process which port to listen to.
var port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
var url = $"http://0.0.0.0:{port}";
var target = Environment.GetEnvironmentVariable("TARGET") ?? "World";

var app = builder.Build();

app.MapGet("/", () => $"Hello {target}!");

app.Run(url);

Aplikasi Anda sudah jadi dan siap dipaketkan dalam container Docker, lalu diupload ke Artifact Registry.

PHP

Buat direktori baru bernama helloworld-gke dan pindahlah ke direktori ini:
```
mkdir helloworld-gke
cd helloworld-gke
```

Buat file bernama index.php dan tempelkan kode berikut ke dalamnya:

<?php
$target = getenv('TARGET', true) ?: 'World';
echo sprintf("Hello %s!", $target);
?>

Aplikasi Anda sudah jadi dan siap dipaketkan dalam container Docker, lalu diupload ke Artifact Registry.

Memasukkan aplikasi ke dalam container dengan Cloud Build

Untuk memasukkan aplikasi contoh ke dalam container, buat file baru bernama Dockerfile di dalam direktori yang sama dengan file sumber, lalu salin konten berikut:

Go

# Use the offical Go image to create a build artifact.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.22.0 as builder
WORKDIR /app

# Initialize a new Go module.
RUN go mod init quickstart-go

# Copy local code to the container image.
COPY *.go ./

# Build the command inside the container.
RUN CGO_ENABLED=0 GOOS=linux go build -o /quickstart-go

# Use a Docker multi-stage build to create a lean production image.
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM gcr.io/distroless/base-debian11

# Change the working directory.
WORKDIR /

# Copy the binary to the production image from the builder stage.
COPY --from=builder /quickstart-go /quickstart-go

# Run the web service on container startup.
USER nonroot:nonroot
ENTRYPOINT ["/quickstart-go"]

Node.js

# Use the official lightweight Node.js 16 image.
# https://hub.docker.com/_/node
FROM node:21-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install production dependencies.
RUN npm install --omit=dev

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

# Run the web service on container startup.
CMD [ "npm", "start" ]

Tambahkan juga file .dockerignore untuk memastikan file lokal tidak memengaruhi proses build container:

Dockerfile
README.md
node_modules
npm-debug.log

Python

# Use the official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.12-slim

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

# Install production dependencies.
RUN pip install Flask gunicorn

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 app:app

Tambahkan file .dockerignore untuk memastikan file lokal tidak memengaruhi proses build container:

Dockerfile
README.md
*.pyc
*.pyo
*.pyd
__pycache__

C#

# Use Microsoft's official lightweight .NET images.
FROM mcr.microsoft.com/dotnet/sdk:6.0 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 . ./

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

# Run the web service on container startup in a lean production image.
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build /app/out .

# Start the .dll (will have the same name as your .csproj file)
ENTRYPOINT ["dotnet", "helloworld-gke.dll"]

Tambahkan file .dockerignore untuk memastikan file lokal tidak memengaruhi proses build container:

Dockerfile
README.md
**/obj/
**/bin/

PHP

# Use the official PHP 7.4 image.
# https://hub.docker.com/_/php
FROM php:8.2-apache

# Copy local code to the container image.
COPY index.php /var/www/html/

# Use port 8080 in Apache configuration files.
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://hub.docker.com/_/php#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

Tambahkan file .dockerignore untuk memastikan file lokal tidak memengaruhi proses build container:

Dockerfile
README.md
vendor

Dapatkan ID project Google Cloud Anda:
```
gcloud config get-value project
```
Dalam panduan memulai ini, Anda akan menyimpan container di Artifact Registry dan men-deploy container ke cluster dari registry. Jalankan perintah berikut untuk membuat repositori bernama hello-repo di lokasi yang sama dengan cluster Anda:
```
gcloud artifacts repositories create hello-repo \
    --project=PROJECT_ID \
    --repository-format=docker \
    --location=us-central1 \
    --description="Docker repository"
```
Ganti nilai berikut:
- PROJECT_ID adalah ID project Google Cloud Anda
Bangun image container Anda menggunakan Cloud Build, seperti menjalankan docker build dan docker push, tetapi build terjadi di Google Cloud:
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/PROJECT_ID/hello-repo/helloworld-gke .
```
Image tersebut disimpan di Artifact Registry.

Membuat cluster GKE

Cluster GKE adalah serangkaian virtual machine Compute Engine terkelola yang beroperasi sebagai satu cluster GKE.

Buat cluster.

gcloud container clusters create-auto helloworld-gke \
  --location us-central1

Pastikan Anda memiliki akses ke cluster. Perintah berikut mendaftar node di cluster container Anda yang aktif dan berjalan, serta menunjukkan bahwa Anda memiliki akses ke cluster tersebut.
```
kubectl get nodes
```
Jika Anda mengalami error, baca Panduan Pemecahan Masalah Kubernetes.

Men-deploy ke GKE

Untuk men-deploy aplikasi ke cluster GKE yang telah dibuat, Anda memerlukan dua objek Kubernetes.

Deployment untuk menentukan aplikasi Anda.
Service untuk menentukan cara mengakses aplikasi Anda.

Men-deploy aplikasi

Aplikasi memiliki server frontend yang menangani permintaan web. Anda menentukan resource cluster yang diperlukan untuk menjalankan frontend dalam file baru bernama deployment.yaml. Resource ini disebut Deployment. Anda menggunakan Deployment untuk membuat dan mengupdate ReplicaSet dan Pod yang terkait.

Buat file deployment.yaml di direktori yang sama dengan file Anda lainnya, lalu salin konten berikut. Ganti nilai berikut di file Anda:

$GCLOUD_PROJECT adalah ID project Google Cloud Anda:
$LOCATION adalah lokasi repositori, seperti us-central1.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloworld-gke
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello-app
        # Replace $LOCATION with your Artifact Registry location (e.g., us-west1).
        # Replace $GCLOUD_PROJECT with your project ID.
        image: $LOCATION-docker.pkg.dev/$GCLOUD_PROJECT/hello-repo/helloworld-gke:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
          - name: PORT
            value: "8080"
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
            ephemeral-storage: "1Gi"
          limits:
            memory: "1Gi"
            cpu: "500m"
            ephemeral-storage: "1Gi"

Deploy resource ke cluster:
```
kubectl apply -f deployment.yaml
```
Lacak status Deployment:
```
kubectl get deployments
```
Deployment selesai saat semua deployment AVAILABLE adalah READY.
```
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
helloworld-gke    1/1     1            1           20s
```
Jika Deployment mengalami kesalahan, jalankan kubectl apply -f deployment.yaml lagi untuk mengupdate perubahan pada Deployment.
Setelah Deployment selesai, Anda dapat melihat Pod yang dibuat oleh Deployment:
```
kubectl get pods
```

Men-deploy Layanan

Service menyediakan satu titik akses ke sekumpulan Pod. Meskipun satu Pod dapat diakses, Pod bersifat sementara dan hanya dapat diakses secara andal menggunakan alamat layanan. Di aplikasi Hello World, Layanan "hello" menentukan load balancer untuk mengakses Pod hello-app dari satu alamat IP. Service ini ditentukan dalam file service.yaml.

Buat file service.yaml dengan konten berikut di dalam direktori yang sama dengan file sumber Anda yang lain:
```
# The hello service provides a load-balancing proxy over the hello-app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
apiVersion: v1
kind: Service
metadata:
  name: hello
spec:
  type: LoadBalancer
  selector:
    app: hello
  ports:
  - port: 80
    targetPort: 8080
```
Pod didefinisikan secara terpisah dari service yang menggunakan Pod. Kubernetes menggunakan label untuk memilih pod yang dialamatkan oleh layanan. Dengan label, Anda dapat memiliki service yang menangani Pod dari kumpulan replika yang berbeda dan memiliki beberapa service yang mengarah ke setiap Pod.
Membuat Service Halo Dunia:
```
kubectl apply -f service.yaml
```

Dapatkan alamat IP eksternal service:

kubectl get services

Diperlukan waktu hingga 60 detik untuk mengalokasikan alamat IP. Alamat IP eksternal tercantum di kolom EXTERNAL-IP untuk Service hello.

NAME         TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
hello        LoadBalancer   10.22.222.222   35.111.111.11   80:32341/TCP   1m
kubernetes   ClusterIP      10.22.222.1     <none>          443/TCP        20m

Melihat aplikasi yang di-deploy

Anda kini telah men-deploy semua resource yang diperlukan untuk menjalankan aplikasi Hello World di GKE.

Gunakan alamat IP eksternal dari langkah sebelumnya untuk memuat aplikasi di browser web Anda, dan lihat aplikasi yang sedang berjalan:

 http://EXTERNAL_IP

Atau, Anda dapat melakukan panggilan curl ke alamat IP eksternal service:

curl EXTERNAL_IP

Outputnya menampilkan ini:

Hello World!

Pembersihan

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

Anda akan dikenai biaya untuk instance Compute Engine yang berjalan di cluster, serta untuk image container di Artifact Registry.

Menghapus project

Menghapus project Google Cloud akan menghentikan penagihan untuk semua resource yang digunakan dalam project tersebut.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus cluster dan container

Jika Anda ingin menghapus resource yang digunakan dalam tutorial ini tanpa menghapus project, hapus cluster dan image Anda.

Untuk menghapus cluster menggunakan Google Cloud CLI, jalankan perintah berikut untuk mode yang Anda gunakan:

gcloud container clusters delete helloworld-gke \
    --location us-central1

Untuk menghapus image di repositori Artifact Registry, jalankan perintah berikut:

gcloud artifacts docker images delete \
    us-central1-docker.pkg.dev/PROJECT_ID/hello-repo/helloworld-gke

Langkah selanjutnya

Untuk informasi selengkapnya tentang Kubernetes, lihat referensi berikut:

Pelajari lebih lanjut tentang membuat cluster.
Pelajari Kubernetes lebih lanjut.
Baca dokumentasi referensi kubectl.

Untuk informasi selengkapnya tentang men-deploy ke GKE, lihat referensi berikut:

Untuk mengetahui informasi selengkapnya tentang membuat, mengembangkan, dan menjalankan aplikasi di GKE langsung dari IDE Anda dengan Cloud Code, lihat artikel berikut: