Perkirakan biaya GKE Anda di awal siklus pengembangan menggunakan GitLab

Autopilot Standard

Tutorial ini menunjukkan praktik terbaik untuk mengubah visibilitas biaya Google Kubernetes Engine (GKE) ke tim pengembangan Anda menggunakan GitLab. Menciptakan kesadaran biaya di awal proses pengembangan akan membantu Anda menghindari hal-hal tak terduga pada tagihan Google Cloud Anda. Memindahkan tugas atau informasi ke bagian awal proses terkadang disebut sebagai menggeser ke kiri.

Tutorial ini ditujukan bagi developer, operator, dan praktisi FinOps yang ingin mengoptimalkan biaya di cluster GKE serta yang menggunakan GitLab dalam produksi. Jika Anda menggunakan GitHub, lihat Memperkirakan biaya GKE di awal siklus pengembangan menggunakan GitHub.

Tutorial ini menganggap bahwa Anda telah memahami teknologi berikut:

Ringkasan

Banyak tim yang menggunakan cloud publik tidak terbiasa dengan gaya penagihan bayar sesuai penggunaan. Sering kali, mereka tidak sepenuhnya memahami lingkungan tempat aplikasi mereka berjalan—dalam hal ini GKE. Model operasi FinOps mempromosikan budaya akuntabilitas keuangan. Praktik terbaik FinOps adalah memberikan informasi real-time kepada tim tentang pengeluaran mereka, sehingga masalah biaya dapat ditangani saat muncul.

Dokumen ini menunjukkan cara melangkah lebih jauh dengan memperkirakan biaya sebelum menimbulkan pengeluaran dalam tagihan Anda. Waktu terbaik untuk memperkirakan biaya adalah di awal proses selama pengembangan dan pada waktu peninjauan kode. Dengan cara ini, praktisi dapat memahami dan mendiskusikan alternatif dampak biaya dari fitur baru dan perbaikan bug sebelum menjadi masalah. Diagram berikut merangkum praktik tersebut.

Praktik terbaik untuk memperkirakan biaya lebih awal.

Seperti yang diilustrasikan oleh diagram, developer dapat memperkirakan biaya GKE di lingkungan lokal mereka, idealnya pada waktu build. Perkiraan ini memberi mereka pemahaman yang baik tentang biaya beban kerja produksi bulanan. Saat perbaikan fitur atau bug selesai, mereka dapat mengusulkan permintaan penggabungan yang memicu pipeline CI/CD GitLab untuk memeriksa perbedaan antara biaya lama dan baru. Jika ada peningkatan di atas ambang batas yang telah ditentukan, pipeline akan otomatis meminta peninjauan kode baru. Praktik ini membantu developer lebih menyadari kapasitas beban kerja mereka dan secara proaktif memperbaiki masalah aplikasi, bukan menambahkan lebih banyak resource setiap kali ketidakstabilan ditemukan dalam produksi.

Tujuan

Bangun dan kirim image penaksir biaya Kubernetes.
Buat project GitLab baru.
Mengonfigurasi runner GitLab untuk dijalankan di cluster GKE.
Kirim kode contoh ke repositori GitLab Anda.
Ubah kode dan usulkan permintaan penggabungan untuk melihat cara kerja estimasi biaya.

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.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Di konsol Google Cloud, buka halaman Pemilih project.

Buka pemilih project
Pilih atau buat project Google Cloud.

Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

Pastikan penagihan telah diaktifkan untuk project Google Cloud 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.

Menyiapkan lingkungan Anda

Di Cloud Shell, clone repositori GitHub gke-shift-left-cost:
```
git clone https://github.com/GoogleCloudPlatform/gke-shift-left-cost
cd gke-shift-left-cost
```
Kode dalam repositori ini disusun ke dalam folder berikut:
- Root: Berisi file Dockerfile yang digunakan untuk membuat image penaksir biaya dan file main.go yang menerapkan logika command line untuk penaksir biaya.
- api/: Berisi Go API untuk memanipulasi objek Kubernetes dan membuat estimasi biaya.
- samples/: Berisi contoh manifes Kubernetes sehingga Anda dapat bereksperimen dengan proses sebelum menerapkannya di organisasi Anda.

Setel project ID Google Cloud Anda, serta akun pengguna GitLab dan alamat email Anda:

export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITLAB_USER=YOUR_GITLAB_USER
export GITLAB_EMAIL=YOUR_GITLAB_EMAIL_ADDRESS

gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    compute.googleapis.com \
    container.googleapis.com \
    iamcredentials.googleapis.com \
    artifactregistry.googleapis.com

gcloud config set compute/region us-central1
gcloud config set compute/zone us-central1-f

Ganti kode berikut:

YOUR_PROJECT_ID : project ID Google Cloud untuk project yang Anda gunakan dalam tutorial ini.
YOUR_GITLAB_USER : akun pengguna yang Anda gunakan untuk login ke akun GitLab.
YOUR_GITLAB_EMAIL_ADDRESS: email yang Anda gunakan di akun GitLab.

Jika ingin, Anda dapat menggunakan region dan zona lain untuk tutorial ini.

Membangun dan mengirim image penaksir biaya Kubernetes

Alat penaksir biaya Kubernetes yang disertakan dalam tutorial ini adalah contoh hal yang dapat dilakukan. Platform ini menawarkan kemampuan memperkirakan biaya untuk objek Kubernetes DaemonSet, Deployment, StatefulSet, ReplicaSet, HorizontalPodAutoScaler, dan PersistentVolumeClaim Kubernetes. Anda juga dapat menerapkan alat estimasi biaya sendiri atau mengusulkan permintaan pull dengan peningkatan yang Anda inginkan.

Di Cloud Shell, izinkan application-default menggunakan kredensial Anda:
```
gcloud auth application-default login
```

Bangun biner penaksir biaya Kubernetes:

mkdir ./bin
go test ./api
go build -v -o ./bin/k8s-cost-estimator .

Uji biner dengan mengeksekusi estimasi biaya dalam folder sampel:

./bin/k8s-cost-estimator \
    --k8s ./samples/k8s-cost-estimator-local/app-v1  \
    --config ./samples/k8s-cost-estimator-local/example-conf.yaml \
    --v trace

Pada output, Anda akan melihat tabel Markdown yang berisi detail perkiraan biaya bulanan untuk folder ./samples/k8s-cost-estimator-local/app-v1/. Untuk lebih memahami biaya produksi bulanan aplikasi mereka, developer dapat menjalankan langkah ini sebelum mengirim kode ke repositori jarak jauh.

INFO[0000] Starting cost estimation (version v0.0.1)...
...

|         KIND          | MIN REQUESTED (USD) | MIN REQ + HPA CPU BUFFER (USD) | MAX REQUESTED (USD) | MIN LIMITED (USD) | MAX LIMITED (USD) |
|-----------------------|---------------------|--------------------------------|---------------------|-------------------|-------------------|
| Deployment            |             $133.31 |                        $198.71 |             $266.54 |           $312.83 |           $579.29 |
| StatefulSet           |              $36.33 |                         $36.33 |              $36.33 |            $72.67 |            $72.67 |
| DaemonSet             |              $29.68 |                         $29.68 |              $29.68 |            $53.19 |            $53.19 |
| PersistentVolumeClaim |              $28.88 |                         $28.88 |              $28.88 |            $33.68 |            $33.68 |
| **TOTAL**             |         **$228.20** |                    **$293.60** |         **$361.43** |       **$472.38** |       **$738.83** |

INFO[0002] Finished cost estimation!

Bangun image container estimator biaya Kubernetes:

docker build . -t \
us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Buat repositori Docker Artifact Registry untuk menyimpan image:

gcloud artifacts repositories create docker-repo \
        --repository-format=docker \
        --location=us-central1 \
        --description="Docker repository"

Daftarkan gcloud sebagai helper kredensial ke file konfigurasi Docker.
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```
Jika diminta, konfirmasi pembaruan file.

Kirim image ke Artifact Registry:

docker push us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Membuat project GitLab baru

Di Cloud Shell, ubah direktori menjadi contoh GitLab:
```
cd samples/k8s-cost-estimator-gitlab
```
Di halaman Personal access tokens GitLab, buat token akses:

Buka halaman token akses pribadi GitLab
1. Di kolom Name, masukkan nama token yang Anda buat.
2. Di kolom Scope, pilih api, lalu klik Create personal access token.
3. Salin nilai Your new personal access token.
Di Cloud Shell, simpan token akses pribadi Anda dalam variabel:
```
GITLAB_API_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN
```
Ganti YOUR_NEW_PERSONAL_ACCESS_TOKEN dengan token akses pribadi GitLab yang Anda buat.

Buat project GitLab baru:

GITLAB_PROJECT_OUTPUT=$(curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d '{"name":"k8s-cost-estimator-gitlab","visibility":"public"}'        https://gitlab.com/api/v4/projects)
GITLAB_PROJECT_ID=$(echo $GITLAB_PROJECT_OUTPUT | jq ".id")
GITLAB_FINOPS_REVIEWER_ID=$(echo $GITLAB_PROJECT_OUTPUT | jq ".owner.id")

Tetapkan variabel untuk alat penaksir biaya yang akan digunakan saat permintaan penggabungan dibuat:

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_API_TOKEN\",\"value\": \"$GITLAB_API_TOKEN\", \"masked\":\"true\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_FINOPS_REVIEWER_ID\",\"value\": \"$GITLAB_FINOPS_REVIEWER_ID\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

curl -X POST -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" -d "{\"key\": \"GITLAB_FINOPS_COST_USD_THRESHOLD\",\"value\": \"10\"}" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables

Pastikan bahwa project dan variabel Anda telah dibuat:
```
curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" \
https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/variables | jq
```
Outputnya mirip dengan hal berikut ini:
```
[
    {
    "variable_type": "env_var",
    "key": "GITLAB_API_TOKEN",
    "value": "Ex...n1",
    "protected": false,
    "masked": true,
    "environment_scope": "*"
    },
    {
    "variable_type": "env_var",
    "key": "GITLAB_FINOPS_REVIEWER_ID",
    "value": "88..87",
    "protected": false,
    "masked": false,
    "environment_scope": "*"
    },
    {
    "variable_type": "env_var",
    "key": "GITLAB_FINOPS_COST_USD_THRESHOLD",
    "value": "10",
    "protected": false,
    "masked": false,
    "environment_scope": "*"
    }
]
```
Variabel yang dikonfigurasi dalam project GitLab Anda digunakan oleh file ./samples/k8s-cost-estimator-gitlab/templates/.gitlab-ci.yml.tpl untuk memperbarui permintaan penggabungan dan adalah sebagai berikut:
- GITLAB_API_TOKEN: Token akses pribadi GitLab Anda.
- GITLAB_FINOPS_REVIEWER_ID: Peninjau kode yang diperlukan setiap kali biaya meningkat di atas ambang batas tertentu. Untuk mempermudah, tutorial ini menetapkan ID pengguna Anda sendiri sebagai peninjau. Namun, dalam lingkungan produksi, sebaiknya Anda mengonfigurasi tim, bukan individu.
- GITLAB_FINOPS_COST_USD_THRESHOLD: Nilai minimum dalam USD, dalam hal ini $10. Saat perbedaan antara biaya lama dan baru melewati batas ini, persetujuan yang luar biasa akan diberlakukan. Anda juga dapat menetapkan batas untuk nilai-nilai lainnya. Untuk mempelajari fitur ini, Anda dapat menambahkan parameter --output saat menjalankan perintah ./bin/k8s-cost-estimator di Membangun dan mengirim image penaksir biaya Kubernetes. Parameter ini menghasilkan file dengan ekstensi .diff yang memungkinkan Anda melihat opsi yang tersedia.

Mengonfigurasi runner GitLab untuk dijalankan di cluster GKE

Di bagian ini, Anda akan menginstal runner GitLab di cluster GKE Anda sendiri dengan Workload Identity agar alat estimator Kubernetes dapat mengkueri Katalog Harga Google Cloud. Estimasi menggunakan harga kotor dan tidak memperhitungkan preemptible VM atau diskon apa pun.

Di Cloud Shell, buat cluster GKE:

gcloud beta container clusters create gitlab-runners \
    --enable-ip-alias \
    --release-channel=stable \
    --workload-pool=$GCP_PROJECT_ID.svc.id.goog \
    --enable-autoprovisioning --min-cpu 1 --min-memory 1 --max-cpu 4 --max-memory 16 \
    --autoscaling-profile=optimize-utilization \
    --preemptible

Dapatkan token pendaftaran runner GitLab dari project yang Anda buat:

export GITLAB_RUNNER_TOKEN=$(curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID | jq -r '.runners_token')
[ -z "$GITLAB_RUNNER_TOKEN" ] && echo "GITLAB_RUNNER_TOKEN is not exported" || echo "GITLAB_RUNNER_TOKEN is $GITLAB_RUNNER_TOKEN"

Instal runner GitLab di cluster GKE Anda:

kubectl create namespace gitlab

helm repo add gitlab https://charts.gitlab.io

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITLAB_RUNNER_TOKEN/$GITLAB_RUNNER_TOKEN/g" templates/gitlab-runner-values.yaml.tpl > gitlab-runner-values.yaml

helm install --namespace gitlab --version 0.24.0 gitlab-runner -f gitlab-runner-values.yaml gitlab/gitlab-runner

kubectl -n gitlab wait --for=condition=available deployment gitlab-runner --timeout=5m

gcloud iam service-accounts create gitlab-runner --display-name=gitlab-runner
gcloud iam service-accounts add-iam-policy-binding \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$GCP_PROJECT_ID.svc.id.goog[gitlab/gitlab-runner]" \
    gitlab-runner@$GCP_PROJECT_ID.iam.gserviceaccount.com

Nonaktifkan runner bersama di project GitLab Anda:

curl -s --header "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" -X PUT "https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID" --form "shared_runners_enabled=false"

Pastikan runner yang Anda deploy telah diaktifkan di project GitLab:

curl -s --header "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" "https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/runners?status=active" | jq '.[] | select(.is_shared==false)'

Outputnya mirip dengan hal berikut ini:

{
    "id": 49345561,
    "description": "gitlab-runner-gitlab-runner-788459d488-jlscn",
    "ip_address": "35.178.223.199",
    "active": true,
    "is_shared": false,
    "name": "gitlab-runner",
    "online": true,
    "status": "online"
}

Kirim kode contoh ke repositori GitLab Anda

Buat pasangan kunci SSH untuk mengirim kode contoh ke repositori GitLab Anda:

mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f gitlab-key
eval `ssh-agent` && ssh-add $(pwd)/gitlab-key
curl -s --request POST --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/user/keys --form "title=k8s-cost-estimator-key" --form "key=$(cat gitlab-key.pub)"
cd ..

Kirim konten ke repositori GitLab baru Anda:

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITLAB_USER/$GITLAB_USER/g; s/GITLAB_EMAIL/$GITLAB_EMAIL/g;" templates/.gitlab-ci.yml.tpl > .gitlab-ci.yml

GITLAB_SSH_URL_REPO=$(curl -s --header "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/users/$GITLAB_FINOPS_REVIEWER_ID/projects | jq '.[] | select(.name=="k8s-cost-estimator-gitlab")' | jq -r '.ssh_url_to_repo')
[ -z "$GITLAB_SSH_URL_REPO" ] && echo "GITLAB_PROJECT_SSH_URL is not exported" || echo "GITLAB_PROJECT_SSH_URL is $GITLAB_SSH_URL_REPO"

git config --global user.email $GITLAB_EMAIL
git config --global user.name $GITLAB_USER
git init
git remote add origin $GITLAB_SSH_URL_REPO
git add -A .
git commit -m "Initial commit"
git checkout -b main
git push -u origin main

Ubah kode dan usulkan permintaan penggabungan untuk melihat cara kerja estimasi biaya

Di Cloud Shell, dapatkan URL untuk GitLab Web Integrated Development Environment (IDE):

echo "https://gitlab.com/-/ide/project/$GITLAB_USER/k8s-cost-estimator-gitlab/tree/main/-/wordpress/wordpress_hpa.yaml"

Ctrl + klik (Cmd + klik di macOS) URL output untuk membuka IDE Web GitLab.
Di IDE Web GitLab, edit file ./wordpress/wordpress_hpa.yaml sebagai berikut:
1. Ubah nilai minReplicas dari 2 menjadi 5.
2. Klik Commit.
Seperti yang ditunjukkan dalam screenshot berikut, pilih Create a new branch dan Start a new merge request, lalu klik Commit.
Di layar New merge.request, klik Create merge request di bagian bawah halaman.

Selain membuat permintaan penggabungan baru, langkah ini memicu pipeline estimasi biaya berdasarkan file .gitlab-ci.yml. Pipeline ini menggunakan image container yang Anda buat di bagian sebelumnya. Pipeline ini juga menentukan kapan persetujuan FinOps diperlukan. Agar lebih mudah, .gitlab-ci.yml menambahkan persetujuan untuk setiap basis permintaan penggabungan, tetapi Anda dapat menentukan dan menggunakan kembali aturan persetujuan yang ditentukan di level project GitLab.
Tunggu sekitar satu menit hingga pipeline selesai. Setelah selesai, komentar dengan detail biaya akan ditambahkan dalam permintaan penggabungan. Karena kenaikan biaya kode yang Anda usulkan melebihi batas $10, peninjau FinOps juga akan diminta.

Outputnya mirip dengan hal berikut ini:

Dalam tutorial ini, konfigurasi default digunakan untuk persetujuan permintaan penggabungan. Anda dapat memilih konfigurasi yang berbeda untuk permintaan penggabungan di Gitlab. Misalnya, untuk mencegah penulis menyetujui permintaan penggabungan buka Setelan > Umum > permintaan penggabungan (MR) > Setelan persetujuan.

Pembersihan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, Anda dapat menghapus project Anda.

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.

Menghapus project GitLab

Jika Anda tidak ingin menyimpan project GitLab, lakukan hal berikut:

Di Cloud Shell, hapus project GitLab Anda:

 curl -X DELETE -H "content-type:application/json" -H "PRIVATE-TOKEN:$GITLAB_API_TOKEN" https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID
```

 The output is similar to the following:

 ```none {:.devsite-disable-click-to-copy}
 {"message":"202 Accepted"}

Jika tidak terhubung dengan Cloud Shell, Anda harus menetapkan variabel berikut lagi:

GITLAB_API_TOKEN
GITLAB_PROJECT_ID

Langkah selanjutnya

Pelajari lebih lanjut pengoptimalan biaya GKE di Praktik terbaik untuk menjalankan aplikasi Kubernetes yang hemat biaya di GKE.
Baca cara memperkirakan biaya GKE di awal siklus pengembangan menggunakan GitHub.
Temukan rekomendasi desain dan praktik terbaik untuk mengoptimalkan biaya workload Google Cloud di Framework Arsitektur Google Cloud: Pengoptimalan biaya.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.