Mengurangi biaya dengan memperkecil skala cluster GKE di luar jam sibuk.

Last reviewed 2022-11-24 UTC

Autopilot Standard

Tutorial ini menjelaskan cara mengurangi biaya dengan men-deploy autoscaler terjadwal di Google Kubernetes Engine (GKE). Autoscaler semacam ini meningkatkan atau memperkecil skala cluster sesuai jadwal berdasarkan waktu atau hari dalam seminggu. Autoscaler terjadwal berguna jika traffic Anda memiliki kondisi naik turun yang dapat diprediksi—misalnya, jika Anda adalah retailer regional, atau jika software ditujukan untuk karyawan yang jam kerjanya terbatas pada waktu tertentu dalam sehari.

Tutorial ini ditujukan untuk developer dan operator yang ingin meningkatkan skala cluster dengan andal sebelum lonjakan tiba, lalu memperkecil skalanya lagi untuk menghemat uang pada malam hari, akhir pekan, atau waktu lain saat jumlah pengguna yang online lebih sedikit. Artikel ini mengasumsikan Anda sudah memahami Docker, Kubernetes, Kubernetes CronJobs, GKE, dan Linux.

Pengantar

Banyak aplikasi mengalami pola traffic yang tidak merata. Misalnya, pekerja di suatu organisasi mungkin hanya berinteraksi dengan aplikasi pada siang hari. Akibatnya, server pusat data untuk aplikasi tersebut tidak ada aktivitas pada malam hari.

Selain manfaat lainnya, Google Cloud dapat membantu Anda menghemat uang dengan mengalokasikan infrastruktur secara dinamis sesuai dengan muatan traffic. Dalam beberapa kasus, konfigurasi penskalaan otomatis sederhana dapat mengelola tantangan alokasi untuk traffic yang tidak merata. Jika itu yang terjadi, tetaplah lakukan. Namun, di kasus lain, perubahan besar pada pola traffic memerlukan konfigurasi penskalaan otomatis yang lebih disesuaikan untuk menghindari ketidakstabilan sistem selama peningkatan skala dan penyediaan cluster yang berlebihan.

Tutorial ini berfokus pada skenario saat perubahan besar dalam pola traffic dapat dipahami dengan baik, dan Anda ingin memberikan petunjuk kepada autoscaler bahwa infrastruktur Anda akan mengalami lonjakan. Dokumen ini menunjukkan cara meningkatkan skala cluster GKE pada pagi hari dan mengecilkannya malam hari, tetapi Anda dapat menggunakan pendekatan serupa untuk meningkatkan dan mengurangi kapasitas untuk setiap peristiwa yang diketahui, seperti peristiwa skala puncak, kampanye iklan, traffic akhir pekan, dan sebagainya.

Memperkecil skala cluster jika Anda memiliki diskon abonemen

Tutorial ini menjelaskan cara mengurangi biaya dengan memperkecil skala cluster GKE hingga batas minimum di luar jam sibuk. Namun, jika telah membeli diskon abonemen, penting untuk memahami cara kerja diskon ini sehubungan dengan penskalaan otomatis.

Kontrak abonemen memberi Anda harga diskon yang sangat besar jika Anda berkomitmen untuk membayar sejumlah resource (vCPU, memori, dan lainnya). Namun, untuk menentukan jumlah resource yang akan di-commit, Anda harus mengetahui terlebih dahulu berapa banyak resource yang digunakan workload Anda dari waktu ke waktu. Untuk membantu mengurangi biaya, diagram berikut menggambarkan resource yang boleh dan tidak boleh Anda sertakan dalam perencanaan.

Distribusi resource, menunjukkan basis resource yang di-commit yang selalu dialokasikan dan resource diskalakan secara otomatis sebagai respons terhadap permintaan (lonjakan).

Seperti yang ditunjukkan pada diagram, alokasi resource berdasarkan kontrak abonemen bersifat tidak berubah. Resource yang tercakup dalam kontrak harus digunakan sepanjang waktu agar sesuai dengan komitmen yang Anda buat. Oleh karena itu, Anda tidak boleh menyertakan resource yang digunakan selama lonjakan dalam menghitung resource yang di-commit. Untuk resource yang meningkat, sebaiknya gunakan opsi autoscaler GKE. Opsi ini mencakup autoscaler terjadwal yang dibahas dalam makalah ini atau opsi terkelola lainnya yang dibahas dalam Praktik terbaik untuk menjalankan aplikasi hemat biaya Kubernetes di GKE.

Jika sudah memiliki kontrak abonemen untuk jumlah resource tertentu, Anda tidak mengurangi biaya dengan memperkecil skala cluster di bawah batas minimum tersebut. Dalam skenario seperti itu, sebaiknya Anda mencoba menjadwalkan beberapa tugas untuk mengisi kesenjangan selama periode permintaan komputasi yang rendah.

Arsitektur

Diagram berikut menunjukkan arsitektur untuk infrastruktur dan autoscaler terjadwal yang Anda deploy dalam tutorial ini. Autoscaler terjadwal terdiri dari serangkaian komponen yang bekerja sama untuk mengelola penskalaan berdasarkan jadwal.

Arsitektur menampilkan komponen yang bersama-sama membentuk autoscaler terjadwal.

Dalam arsitektur ini, kumpulan CronJobs Kubernetes mengekspor informasi umum tentang pola traffic ke metrik kustom Cloud Monitoring. Data ini kemudian dibaca oleh Horizontal Pod Autoscaler (HPA) Kubernetes sebagai input tentang kapan HPA harus menskalakan workload Anda. Bersama dengan metrik muatan lainnya, seperti pemanfaatan CPU target, HPA menentukan cara menskalakan replika untuk deployment tertentu.

Tujuan

Membuat cluster GKE.
Men-deploy aplikasi contoh yang menggunakan HPA Kubernetes.
Menyiapkan komponen untuk autoscaler terjadwal dan memperbarui HPA Anda untuk membaca dari metrik kustom terjadwal.
Menyiapkan pemberitahuan yang akan dipicu saat austoscaler terjadwal Anda tidak berfungsi dengan benar.
Menghasilkan muatan ke aplikasi.
Memeriksa cara HPA merespons peningkatan traffic normal dan metrik kustom terjadwal yang Anda konfigurasikan.

Kode untuk tutorial ini ada di repositori GitHub.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

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

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API GKE, Artifact Registry and the Cloud Monitoring.

Mengaktifkan API

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

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API GKE, Artifact Registry and the Cloud Monitoring.

Mengaktifkan API

Menyiapkan lingkungan Anda

Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell

Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.
Di Cloud Shell, konfigurasikan ID project Google Cloud, alamat email, serta zona komputasi dan region Anda:
```
PROJECT_ID=YOUR_PROJECT_ID
ALERT_EMAIL=YOUR_EMAIL_ADDRESS
gcloud config set project $PROJECT_ID
gcloud config set compute/region us-central1
gcloud config set compute/zone us-central1-f
```
Ganti kode berikut:
- YOUR_PROJECT_ID: nama project Google Cloud untuk project yang Anda gunakan.
- YOUR_EMAIL_ADDRESS: alamat email untuk menerima pemberitahuan saat autoscaler terjadwal tidak berfungsi dengan benar.
Anda dapat memilih region dan zona lain untuk tutorial ini jika mau.
Clone repositori GitHub kubernetes-engine-samples:
```
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/
cd kubernetes-engine-samples/cost-optimization/gke-scheduled-autoscaler
```
Kode dalam contoh ini disusun ke dalam folder berikut:
- Root: Berisi kode yang digunakan oleh CronJobs untuk mengekspor metrik kustom ke Cloud Monitoring.
- k8s/: Berisi contoh deployment yang memiliki HPA Kubernetes.
- k8s/scheduled-autoscaler/: Berisi CronJobs yang mengekspor metrik kustom dan versi HPA yang diupdate untuk dibaca dari metrik kustom.
- k8s/load-generator/: Berisi deployment Kubernetes yang memiliki aplikasi untuk menyimulasikan penggunaan per jam.
- monitoring/: Berisi komponen Cloud Monitoring yang Anda konfigurasikan dalam tutorial ini.

Membuat cluster GKE

Di Cloud Shell, buat cluster GKE untuk menjalankan autoscaler terjadwal:

gcloud container clusters create scheduled-autoscaler \
    --enable-ip-alias \
    --release-channel=stable \
    --machine-type=e2-standard-2 \
    --enable-autoscaling --min-nodes=1 --max-nodes=10 \
    --num-nodes=1 \
    --autoscaling-profile=optimize-utilization

Outputnya mirip dengan hal berikut ini:

NAME                   LOCATION       MASTER_VERSION   MASTER_IP      MACHINE_TYPE   NODE_VERSION     NUM_NODES  STATUS
scheduled-autoscaler   us-central1-f  1.22.15-gke.100  34.69.187.253  e2-standard-2  1.22.15-gke.100  1          RUNNING

Ini bukan konfigurasi produksi, namun konfigurasi yang sesuai untuk tutorial ini. Dalam penyiapan ini, Anda mengonfigurasi autoscaler cluster dengan minimal 1 node dan maksimum 10 node. Anda juga mengaktifkan profil optimize-utilization untuk mempercepat proses pengecilan skala.

Men-deploy aplikasi contoh

Deploy aplikasi contoh tanpa autoscaler terjadwal:
```
kubectl apply -f ./k8s
```
Buka file k8s/hpa-example.yaml.

Daftar berikut menampilkan konten file.
```
spec:
  maxReplicas: 20
  minReplicas: 10
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60
```
Perhatikan bahwa jumlah minimum replika (minReplicas) ditetapkan ke 10. Konfigurasi ini juga menetapkan cluster untuk diskalakan berdasarkan pemakaian CPU (setelan name: cpu dan type: Utilization).

Tunggu hingga aplikasi tersedia:

kubectl wait --for=condition=available --timeout=600s deployment/php-apache
EXTERNAL_IP=''
while [ -z $EXTERNAL_IP ]
do
    EXTERNAL_IP=$(kubectl get svc php-apache -o jsonpath={.status.loadBalancer.ingress[0].ip})
    [ -z $EXTERNAL_IP ] && sleep 10
done
curl -w '\n' http://$EXTERNAL_IP

Jika aplikasi tersedia, outputnya adalah sebagai berikut:

OK!

Pastikan setelan:

kubectl get hpa php-apache

Outputnya mirip dengan hal berikut ini:

NAME         REFERENCE               TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache   9%/60%    10        20        10         6d19h

Kolom REPLICAS menampilkan 10, yang cocok dengan nilai kolom minReplicas di file hpa-example.yaml.

Periksa apakah jumlah node telah bertambah menjadi 4:
```
kubectl get nodes
```
Outputnya mirip dengan hal berikut ini:
```
NAME                                                  STATUS   ROLES    AGE   VERSION
gke-scheduled-autoscaler-default-pool-64c02c0b-9kbt   Ready    &lt;none>   21S   v1.17.9-gke.1504
gke-scheduled-autoscaler-default-pool-64c02c0b-ghfr   Ready    &lt;none>   21s   v1.17.9-gke.1504
gke-scheduled-autoscaler-default-pool-64c02c0b-gvl9   Ready    &lt;none>   21s   v1.17.9-gke.1504
gke-scheduled-autoscaler-default-pool-64c02c0b-t9sr   Ready    &lt;none>   21s   v1.17.9-gke.1504
```
Saat membuat cluster, Anda menetapkan konfigurasi minimum menggunakan flag min-nodes=1. Namun, aplikasi yang Anda deploy di awal prosedur ini meminta lebih banyak infrastruktur karena minReplicas di file hpa-example.yaml ditetapkan ke 10.

Menetapkan minReplicas ke nilai seperti 10 adalah strategi umum yang digunakan oleh perusahaan seperti retailer, yang memperkirakan peningkatan traffic secara tiba-tiba dalam beberapa jam pertama hari kerja. Namun, menetapkan nilai tinggi untuk HPA minReplicas dapat meningkatkan biaya karena cluster tidak dapat berkurang, bahkan pada malam hari saat traffic aplikasi rendah.

Menyiapkan autoscaler terjadwal

Di Cloud Shell, instal Metrik Kustom - adaptor Cloud Monitoring di cluster GKE Anda:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
kubectl wait --for=condition=available --timeout=600s deployment/custom-metrics-stackdriver-adapter -n custom-metrics

Adaptor ini mengaktifkan penskalaan otomatis Pod berdasarkan metrik kustom Cloud Monitoring

Buat repositori di Artifact Registry dan berikan izin baca:

gcloud artifacts repositories create gke-scheduled-autoscaler \
  --repository-format=docker --location=us-central1
gcloud auth configure-docker us-central1-docker.pkg.dev
gcloud artifacts repositories add-iam-policy-binding gke-scheduled-autoscaler \
   --location=us-central1 --member=allUsers --role=roles/artifactregistry.reader

Buat dan kirim kode pengekspor metrik kustom:

docker build -t us-central1-docker.pkg.dev/$PROJECT_ID/gke-scheduled-autoscaler/custom-metric-exporter .
docker push us-central1-docker.pkg.dev/$PROJECT_ID/gke-scheduled-autoscaler/custom-metric-exporter

Deploy CronJobs yang mengekspor metrik kustom dan men-deploy versi HPA yang telah diupdate dan membaca dari metrik kustom ini:

sed -i.bak s/PROJECT_ID/$PROJECT_ID/g ./k8s/scheduled-autoscaler/scheduled-autoscale-example.yaml
kubectl apply -f ./k8s/scheduled-autoscaler

Buka dan periksa file k8s/scheduled-autoscaler/scheduled-autoscale-example.yaml.

Daftar berikut menampilkan konten file.

apiVersion: batch/v1
kind: CronJob
metadata:
  name: scale-up
spec:
  schedule: "50-59/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: custom-metric-extporter
            image: us-central1-docker.pkg.dev/PROJECT_ID/gke-scheduled-autoscaler/custom-metric-exporter
            command:
              - /export
              - --name=scheduled_autoscaler_example
              - --value=10
          restartPolicy: OnFailure
      backoffLimit: 1
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name: scale-down
spec:
  schedule: "1-49/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: custom-metric-extporter
            image: us-central1-docker.pkg.dev/PROJECT_ID/gke-scheduled-autoscaler/custom-metric-exporter
            command:
              - /export
              - --name=scheduled_autoscaler_example
              - --value=1
          restartPolicy: OnFailure
      backoffLimit: 1

Konfigurasi ini menentukan bahwa CronJobs harus mengekspor jumlah replika Pod yang disarankan ke metrik kustom yang disebut custom.googleapis.com/scheduled_autoscaler_example berdasarkan waktu. Untuk memfasilitasi bagian pemantauan tutorial ini, konfigurasi kolom jadwal menentukan peningkatan dan pengecilan skala per jam. Untuk produksi, Anda dapat menyesuaikan jadwal ini agar sesuai dengan kebutuhan bisnis.

Buka dan periksa file k8s/scheduled-autoscaler/hpa-example.yaml.

Daftar berikut menampilkan isi file.
```
spec:
  maxReplicas: 20
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60
  - type: External
    external:
      metric:
        name: custom.googleapis.com|scheduled_autoscaler_example
      target:
          type: AverageValue
          averageValue: 1
```
Konfigurasi ini menentukan bahwa objek HPA harus menggantikan HPA yang di-deploy sebelumnya. Perhatikan bahwa konfigurasi ini mengurangi nilai di minReplicas menjadi 1. Ini berarti workload dapat diperkecil skalanya hingga batas minimum. Konfigurasi tersebut juga menambahkan metrik eksternal (type: External). Penambahan ini berarti penskalaan otomatis kini dipicu oleh dua faktor.

Dalam skenario multi-metrik ini, HPA menghitung jumlah replika yang diusulkan untuk setiap metrik, lalu memilih metrik yang menampilkan nilai tertinggi. Penting untuk memahami hal ini—autoscaler terjadwal Anda dapat mengusulkan bahwa pada waktu tertentu jumlah Pod harus 1. Namun, jika pemakaian CPU sebenarnya lebih tinggi dari yang diharapkan untuk satu Pod, HPA akan membuat lebih banyak replika.
Periksa lagi jumlah node dan replika HPA dengan menjalankan lagi setiap perintah berikut:
```
kubectl get nodes
kubectl get hpa php-apache
```
Output yang Anda lihat tergantung pada tindakan yang telah dilakukan oleh autoscaler terjadwal baru-baru ini—khususnya, nilai minReplicas dan nodes akan berbeda pada titik yang berbeda dalam siklus penskalaan.

Misalnya, pada sekitar menit 51 hingga 60 setiap jam (yang menunjukkan periode traffic puncak), nilai HPA untuk minReplicas adalah 10 dan nilai nodes adalah 4.

Sebaliknya, untuk menit 1 hingga 50 (yang mewakili periode traffic yang lebih rendah), nilai minReplicas HPA adalah 1 dan nilai nodes adalah 1 atau 2, tergantung pada seberapa banyak Pod yang telah dialokasikan dan dihapus. Untuk nilai yang lebih rendah (menit 1 hingga 50), mungkin perlu waktu hingga 10 menit bagi cluster untuk memperkecil skala.

Mengonfigurasi pemberitahuan saat autoscaler terjadwal tidak berfungsi dengan benar

Di lingkungan produksi, Anda biasanya ingin mengetahui kapan CronJobs tidak mengisi metrik kustom. Untuk tujuan ini, Anda dapat membuat pemberitahuan yang terpicu saat tidak ada streaming custom.googleapis.com/scheduled_autoscaler_example selama lima menit.

Di Cloud Shell, buat saluran notifikasi:

gcloud beta monitoring channels create \
    --display-name="Scheduled Autoscaler team (Primary)" \
    --description="Primary contact method for the Scheduled Autoscaler team lead"  \
    --type=email \
    --channel-labels=email_address=${ALERT_EMAIL}

Outputnya mirip dengan hal berikut ini:

Created notification channel NOTIFICATION_CHANNEL_ID.

Perintah ini membuat saluran notifikasi berjenis email untuk menyederhanakan langkah tutorial. Di lingkungan produksi, sebaiknya gunakan strategi yang lebih tidak asinkron dengan menetapkan saluran notifikasi ke sms atau pagerduty.

Tetapkan variabel yang memiliki nilai yang ditampilkan di placeholder NOTIFICATION_CHANNEL_ID:
```
NOTIFICATION_CHANNEL_ID=NOTIFICATION_CHANNEL_ID
```

Deploy kebijakan pemberitahuan:

gcloud alpha monitoring policies create \
    --policy-from-file=./monitoring/alert-policy.yaml \
    --notification-channels=$NOTIFICATION_CHANNEL_ID

File alert-policy.yaml berisi spesifikasi untuk mengirim pemberitahuan jika metrik tidak ada setelah lima menit.

Buka halaman Pemberitahuan Cloud Monitoring untuk melihat kebijakan pemberitahuan.

Buka Pemberitahuan
Klik Kebijakan Autoscaler Terjadwal dan verifikasi detail kebijakan pemberitahuan.

Menghasilkan muatan ke aplikasi contoh

Di Cloud Shell, deploy pembuat muatan:
```
kubectl apply -f ./k8s/load-generator
```
Daftar berikut menampilkan skrip load-generator:
```
command: ["/bin/sh", "-c"]
args:
&#45; while true; do
    RESP=$(wget -q -O- http://php-apache.default.svc.cluster.local);
    echo "$(date +%H)=$RESP";
    sleep $(date +%H | awk '{ print "s("$0"/3*a(1))*0.5+0.5" }' | bc -l);
  done;
```
Skrip ini berjalan di cluster sampai Anda menghapus deployment load-generator. Fungsi ini membuat permintaan ke layanan php-apache setiap beberapa milidetik. Perintah sleep menyimulasikan perubahan distribusi muatan sepanjang hari. Dengan menggunakan skrip yang menghasilkan traffic melalui cara ini, Anda dapat memahami apa yang terjadi saat menggabungkan pemakaian CPU dan metrik kustom dalam konfigurasi HPA.

Memvisualisasikan penurunan skala sebagai respons terhadap traffic atau metrik terjadwal

Di bagian ini, Anda akan meninjau visualisasi yang menunjukkan efek peningkatan dan pengecilan skala.

Di Cloud Shell, buat dasbor baru:

gcloud monitoring dashboards create \
    --config-from-file=./monitoring/dashboard.yaml

Buka halaman Dasbor Cloud Monitoring:

Buka Dashboards
Klik Dasbor Autoscaler Terjadwal.

Dasbor menampilkan tiga grafik. Anda harus menunggu minimal 2 jam (idealnya, 24 jam atau lebih) untuk melihat dinamika peningkatan dan pengecilan skala, dan untuk melihat pengaruh distribusi muatan yang berbeda sepanjang hari terhadap penskalaan otomatis.

Catatan: Perlu diketahui bahwa Anda akan ditagih untuk resource yang berjalan saat melakukan pengujian.

Untuk memberi Anda gambaran tentang apa yang ditampilkan grafik, Anda dapat mempelajari grafik berikut, yang menyajikan tampilan sehari penuh:
- Metrik Terjadwal (# Pod yang diinginkan) menunjukkan deret waktu metrik kustom yang diekspor ke Cloud Monitoring melalui CronJobs yang Anda konfigurasi di Menyiapkan autoscaler terjadwal.
- Pemakaian CPU (diminta vs terpakai) menampilkan deret waktu penggunaan CPU yang diminta (merah) dan pemakaian CPU sebenarnya (biru). Jika muatannya rendah, HPA mengikuti keputusan penggunaan oleh autoscaler terjadwal. Namun, saat traffic meningkat, HPA meningkatkan jumlah Pod sesuai kebutuhan, seperti yang dapat Anda lihat untuk titik data antara pukul 12.00 dan 18.00.
- Jumlah Pod (terjadwal vs aktual) + Rata-rata Pemakaian CPU menunjukkan tampilan serupa dengan yang sebelumnya. Jumlah Pod (merah) meningkat menjadi 10 setiap jam sesuai jadwal (biru). Jumlah pod secara alami meningkat dan berkurang dari waktu ke waktu sebagai respons terhadap muatan (12.00 dan 18.00). Pemakaian CPU rata-rata (oranye) tetap di bawah target yang Anda tetapkan (60%).

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

Perhatian: Menghapus project memiliki efek berikut:

Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

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.

Langkah selanjutnya

Pelajari lebih lanjut pengoptimalan biaya GKE di Praktik terbaik untuk menjalankan aplikasi Kubernetes yang hemat biaya di GKE.
Temukan rekomendasi desain dan praktik terbaik untuk mengoptimalkan biaya workload Google Cloud di Framework Arsitektur Google Cloud: Pengoptimalan biaya.
Untuk mengetahui detail selengkapnya tentang cara menurunkan biaya pada aplikasi batch, lihat Mengoptimalkan penggunaan resource di cluster GKE multi-tenant menggunakan penyediaan otomatis node.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.