Stimare i costi di GKE nelle prime fasi del ciclo di sviluppo utilizzando GitHub

Last reviewed 2022-12-15 UTC

Autopilot Standard

Questo tutorial illustra la best practice per spostare la visibilità dei costi di Google Kubernetes Engine (GKE) al team di sviluppo. Questa pratica di spostamento a sinistra genera consapevolezza dei costi nelle prime fasi del processo, aiutandoti a evitare sorprese nella fattura di Google Cloud.

Questo tutorial è rivolto a sviluppatori, operatori e professionisti FinOps che vogliono ottimizzare i costi nei cluster GKE e che utilizzano GitHub in produzione. Se invece utilizzi GitLab, consulta Stimare i costi di GKE all'inizio del ciclo di sviluppo utilizzando GitLab.

Il tutorial presuppone la conoscenza di Docker, GitHub Kubernetes, GKE, Cloud Build e Linux.

Panoramica

Molti team che adottano il cloud pubblico non sono abituati allo stile di fatturazione con pagamento a consumo. Spesso, non comprendono appieno l'ambiente in cui vengono eseguite le loro app, in questo caso GKE. Il modello operativo FinOps promuove questa cultura della responsabilità finanziaria. Una best practice di FinOps consiste nel fornire ai team informazioni in tempo reale sulle loro spese, in modo da poter risolvere i problemi di costo non appena si presentano.

Questo documento mostra come fare un passo in più facendo una stima dei costi prima che diventino spese in fattura. Come evidenziato nel sito web di GitHub, "Su GitHub, strumenti leggeri di revisione del codice sono integrati in ogni richiesta di pull". Questo ti consente di "evolvere i progetti, proporre nuove funzionalità e discutere dei dettagli dell'implementazione prima di modificare il codice sorgente". Il momento migliore per stimare i costi è nelle prime fasi del processo, durante lo sviluppo e in fase di revisione del codice. In questo modo, i professionisti possono comprendere e discutere delle alternative relative all'impatto sui costi delle nuove funzionalità e delle correzioni di bug prima che diventi un problema. Il seguente diagramma riassume questa pratica.

Best practice per una stima anticipata dei costi.

Come mostrato nel diagramma, uno sviluppatore stima i costi di GKE nel suo ambiente locale, idealmente al momento della creazione. Questa stima consente loro di avere un'idea chiara del costo mensile del carico di lavoro di produzione. Quando la funzionalità o la correzione del bug è completa di codice, propongono una richiesta di pull che attiva Cloud Build per verificare la differenza tra il costo precedente e quello nuovo. Se sono presenti aumenti oltre una soglia predefinita, possono richiedere una nuova revisione del codice. Questa pratica aiuta gli sviluppatori a diventare più consapevoli della capacità dei loro carichi di lavoro e a risolvere in modo proattivo i problemi delle applicazioni, invece di aggiungere altre risorse ogni volta che si rileva instabilità in produzione.

Obiettivi

Crea ed esegui il push dell'immagine dello strumento di stima dei costi di Kubernetes.
Creare un repository GitHub.
Connetti Cloud Build al tuo repository GitHub.
Esegui il push del codice di esempio nel tuo repository GitHub.
Modifica il codice e proponi una richiesta di pull per vedere la stima dei costi in azione.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Nella console Google Cloud, vai alla pagina del selettore progetto.

Vai al selettore progetti
Seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

prepara l'ambiente

In Cloud Shell, clona il repository GitHub di gke-shift-left-cost:
```
git clone https://github.com/GoogleCloudPlatform/gke-shift-left-cost
cd gke-shift-left-cost
```
Il codice in questo repository è strutturato nelle seguenti cartelle:
- Root: contiene un file Dockerfile utilizzato per creare l'immagine dello strumento di stima dei costi e il file main.go che implementa la logica a riga di comando per lo strumento di stima.
- api/: contiene l'API Golang per manipolare gli oggetti Kubernetes e effettuare una stima dei costi.
- samples/: contiene esempi di manifest Kubernetes che ti consentono di sperimentare il processo prima di implementarlo nella tua organizzazione.
Imposta l'ID progetto Google Cloud, l'utente e l'indirizzo email GitHub e un altro utente GitHub che agirà da revisore di FinOps:
```
export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITHUB_USER=YOUR_GITHUB_USER
export GITHUB_EMAIL=YOUR_GITHUB_EMAIL_ADDRESS
export GITHUB_FINOPS_REVIEWER_USER=ANOTHER_GITHUB_USER
```
Sostituisci quanto segue:
- YOUR_PROJECT_ID: l'ID progetto Google Cloud per il progetto utilizzato in questo tutorial.
- YOUR_GITHUB_USER: l'utente che utilizzi per accedere al tuo account GitHub.
- YOUR_GITHUB_EMAIL_ADDRESS: l'email che utilizzi nel tuo account GitHub.
- ANOTHER_GITHUB_USER: un altro utente GitHub che agirà come revisore di FinOps. Tieni presente che questo tutorial richiede l'aggiunta di questo utente come collaboratore al repository, perciò non può riguardare te. Per evitare di rimanere bloccato durante i passaggi del tutorial, assicurati che l'utente accetti il tuo invito non appena lo crei.

Imposta il progetto Google Cloud e abilita le API richieste:

gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com

Crea ed esegui il push dell'immagine dello strumento di stima dei costi di Kubernetes

Lo strumento per la stima dei costi di Kubernetes fornito in questo tutorial è solo un esempio di cosa si può fare. Offre la possibilità di stimare i costi per gli oggetti Kubernetes DaemonSet, Deployment, StatefulSet, ReplicaSet, HorizontalPodAutoScaler e PersistentVolumeClaim Kubernetes. Puoi anche implementare il tuo strumento di stima dei costi o proporre richieste pull con i miglioramenti che preferisci.

In Cloud Shell, consenti a application-default di utilizzare le tue credenziali:
```
gcloud auth application-default login
```
Crea il programma binario dello strumento di stima dei costi di Kubernetes:
```
mkdir ./bin
go test ./api
go build -v -o ./bin/k8s-cost-estimator .
```

Testa il programma binario eseguendo una stima dei costi in una cartella di esempio:

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

Nell'output, viene visualizzata una tabella Markdown che descrive nel dettaglio i costi mensili stimati per la cartella ./samples/k8s-cost-estimator-local/app-v1/. Per comprendere meglio il costo mensile di produzione delle loro applicazioni, gli sviluppatori possono eseguire questo passaggio prima di eseguirne il push al repository remoto.

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!

Crea l'immagine del container dello strumento di stima dei costi di Kubernetes:

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

Crea il repository Docker Artifact Registry per archiviare l'immagine:

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

Registra gcloud come assistente per le credenziali per il file di configurazione di Docker. Se richiesto, conferma l'aggiornamento del file.
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```

Esegui il push dell'immagine ad Artifact Registry:

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

Crea un nuovo repository GitHub

In Cloud Shell, passa alla directory GitHub di esempio:
```
cd samples/k8s-cost-estimator-github
```
In GitHub, crea un token di accesso:

Vai alla pagina GitHub Personal Access Tokens
1. Nel campo Nota, inserisci una descrizione del token.
2. In Seleziona ambiti, seleziona le caselle di controllo repo, admin:public_key ed delete_repo.
3. Fai clic su Genera token e copia il valore Il tuo nuovo token di accesso personale nella parte superiore della pagina.
In Cloud Shell, salva il token di accesso personale in una variabile.
```
GITHUB_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN
```
Sostituisci quanto segue:
- YOUR_NEW_PERSONAL_ACCESS_TOKEN: il token di accesso personale appena creato.

Crea un repository GitHub:

curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/repos \
  -d '{"name":"k8s-cost-estimator-github"}' | jq

L'output è simile al seguente:

{
  "id": 36099474,
  "node_id": "MDEwOldfsdjA5OTQ3Njc=",
  "name": "k8s-cost-estimator-github",
  ...
}

Aggiungi il revisore FinOps come collaboratore nel tuo repository:

curl -X PUT \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github/collaborators/$GITHUB_FINOPS_REVIEWER_USER  | jq -r .html_url

L'output è simile al seguente:

https://github.com/your-user/k8s-cost-estimator-github/invitations

Condividi l'URL di output con l'utente impostato nella variabile GITHUB_FINOPS_REVIEWER_USER in modo che possa accettare l'invito. Prima di continuare con il passaggio successivo, visita lo stesso URL per assicurarti che l'invito sia stato accettato.

Connetti Cloud Build al tuo repository GitHub

Questa sezione mostra come installare l'app GitHub di Cloud Build. Questa installazione consente di connettere il repository GitHub al progetto Google Cloud in modo che Cloud Build possa eseguire automaticamente lo strumento di stima di Kubernetes a ogni richiesta di pull.

Vai alla pagina GitHub Marketplace per l'app Cloud Build:

Apri Cloud Build
Configura l'accesso all'account GitHub per l'app:
1. Se è la prima volta che configuri un'app in GitHub, fai clic su Configura con Google Cloud Build in fondo alla pagina, poi fai clic su Concedi a questa app l'accesso al tuo account GitHub.
2. Se hai già configurato un'app in GitHub, fai clic su Configura l'accesso.
Nella pagina Applicazioni che si apre, segui questi passaggi:
1. Nella riga Google Cloud Build, fai clic su Configura.
2. Seleziona l'opzione Seleziona solo repository.
3. Seleziona k8s-cost-estimator-github per connetterti al repository che hai appena creato.
4. Fai clic su Salva o Installa (l'etichetta del pulsante cambia in base al flusso in esecuzione).
Ti reindirizzeremo a Google Cloud per continuare l'installazione. Accedi con il tuo account Google Cloud. Se richiesto, autorizza l'integrazione di Cloud Build con GitHub.
Nella pagina Cloud Build, seleziona il tuo progetto. Viene visualizzato un mago.
Nella sezione Seleziona repository della procedura guidata, seleziona il tuo account GitHub e il repository k8s-cost-estimator-github.
Se accetti i Termini e condizioni, seleziona la casella di controllo e fai clic su Connetti.
Nella sezione Crea un trigger, fai clic su Crea un trigger, poi segui questi passaggi:
1. Inserisci un nome per l'attivatore.
2. Nella sezione Evento, seleziona Richiesta di pull (solo app GitHub).
3. Nella sezione Fonte:
  - Assicurati che il campo Repository sia compilato automaticamente con your-github-user/k8s-cost-estimator-github (app GitHub).
  - Nel menu a discesa Ramo di base, seleziona .*.
4. Nella sezione Tipo di configurazione, seleziona File di configurazione di Cloud Build (yaml o json).
5. Nella sezione Avanzate, aggiungi le seguenti variabili di sostituzione:
  - _GITHUB_TOKEN = YOUR_PERSONAL_ACCESS_TOKEN
  - _GITHUB_FINOPS_REVIEWER_USER = THE_GITHUB_FINOPS_REVIEWER_USER
  - _GITHUB_FINOPS_COST_USD_THRESHOLD = 10
  Sostituisci quanto segue:
  - YOUR_PERSONAL_ACCESS_TOKEN: il token di accesso personale GitHub che hai creato. Questo token è disponibile nella variabile GITHUB_TOKEN in Cloud Shell.
  - THE_GITHUB_FINOPS_REVIEWER_USER: l'utente che hai invitato come collaboratore nel tuo repository GitHub. Questo nome utente è disponibile nella variabile GITHUB_FINOPS_REVIEWER_USER in Cloud Shell.
Fai clic su Crea.

L'app GitHub di Cloud Build è ora configurata e il repository GitHub è collegato al tuo progetto Google Cloud. Le richieste di pull al tuo repository GitHub ora attivano le esecuzioni di Cloud Build, che riportano i risultati a GitHub utilizzando i controlli GitHub.

Esegui il push del codice di esempio nel repository GitHub

Crea una coppia di chiavi SSH per eseguire il push del codice campione al tuo repository GitHub:

mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f github-key
eval `ssh-agent` && ssh-add $(pwd)/github-key
curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/keys \
  -d "{\"title\":\"k8s-cost-estimator-key\", \"key\":\"$(cat github-key.pub)\"}" | jq
cd ..

L'output è simile al seguente:

{
  "id": 52356205,
  "key": "ssh-rsa AAAAB3NzaC….wJICyt0yvWjGFZGCWBPUw==",
  "url": "https://api.github.com/user/keys/526205",
  "title": "k8s-cost-estimator-key",
  "verified": true,
  "created_at": "2021-04-23T16:22:58Z",
  "read_only": false
}

Esegui il push dei contenuti nel nuovo repository GitHub:

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITHUB_USER/$GITHUB_USER/g; s/GITHUB_EMAIL/$GITHUB_EMAIL/g;" templates/cloudbuild.yaml.tpl > cloudbuild.yaml

GITHUB_SSH_URL_REPO=$(curl -X GET \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github | jq -r .ssh_url)
[ -z "$GITHUB_SSH_URL_REPO" ] && echo "GITHUB_SSH_URL_REPO is not exported" || echo "GITHUB_SSH_URL_REPO is $GITHUB_SSH_URL_REPO"

git init
git remote add origin $GITHUB_SSH_URL_REPO
git add -A .
git commit -m "Initial commit"
git checkout -b main
git push -u origin main

Modifica il codice e crea una richiesta di pull per testare la stima dei costi

In Cloud Shell, recupera l'URL GitHub del file wordpress/wordpress_hpa.yaml:

echo "https://github.com/$GITHUB_USER/k8s-cost-estimator-github/edit/main/wordpress/wordpress_hpa.yaml"

Ctrl+clic (Cmd+clic per utenti Mac) sull'URL di output per passare a GitHub e modificare il file wordpress/wordpress_hpa.yaml.
In GitHub, cambia minReplicas in 5.
Seleziona Crea un nuovo ramo per questo commit e avvia una richiesta di pull, quindi fai clic su Proponi modifiche.
Nella schermata Apri una richiesta di pull, fai clic su Crea richiesta di pull.

Oltre a creare una nuova richiesta di pull, questo passaggio attiva un'esecuzione di Cloud Build basata sul file cloudbuild.yaml che hai creato in precedenza. Questa esecuzione di Cloud Build utilizza l'immagine del container che hai creato in Creazione e push dell'immagine dello strumento di stima dei costi di Kubernetes e prende la decisione quando è richiesto un revisore di FinOps.
Attendi circa un minuto per il completamento della pipeline. Al termine, nella richiesta di pull viene aggiunto un commento con i dettagli dei costi. Inoltre, poiché l'aumento del costo del codice che proponi supera la soglia di 10 $, viene richiesto anche un revisore di FinOps.

L'output è simile al seguente:

Ora sai come dare visibilità agli sviluppatori sulle loro spese nelle prime fasi del ciclo di sviluppo. Questa configurazione consente a te e alla tua organizzazione di evitare sorprese nella fattura di Google Cloud.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eliminare il tuo progetto.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina il repository GitHub

Se non vuoi conservare il repository GitHub, segui questi passaggi:

In Cloud Shell, elimina il repository GitHub:

curl -X DELETE \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github

Se perdi la connessione con Cloud Shell, devi reimpostare le variabili GITHUB_TOKEN e GITHUB_USER.

Passaggi successivi

Se utilizzi GitLab, consulta Stimare i costi di GKE all'inizio del ciclo di sviluppo utilizzando GitLab.
Scopri di più sull'ottimizzazione dei costi di GKE, consulta le best practice per l'esecuzione di applicazioni Kubernetes con ottimizzazione dei costi su GKE.
Trova suggerimenti e best practice di progettazione per ottimizzare il costo dei carichi di lavoro Google Cloud in Framework dell'architettura Google Cloud: ottimizzazione dei costi.
Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.