Questa pagina è stata tradotta dall'API Cloud Translation.

Gestisci LLM aperti su GKE con un'architettura preconfigurata

Questa pagina mostra come eseguire rapidamente il deployment e l'hosting di modelli linguistici di grandi dimensioni (LLM) open source popolari su GKE per l'inferenza utilizzando un'architettura di riferimento preconfigurata e pronta per la produzione. Questo approccio utilizza Infrastructure as Code (IaC), con Terraform incluso negli script CLI, per creare un ambiente GKE standardizzato, sicuro e scalabile progettato per i carichi di lavoro di inferenza AI.

In questa guida, esegui il deployment e la gestione di LLM utilizzando nodi GPU a host singolo su GKE con il framework di gestione vLLM. Questa guida fornisce istruzioni e configurazioni per il deployment dei seguenti modelli aperti:

Questa guida è rivolta a machine learning engineer e specialisti di dati e AI interessati a esplorare le funzionalità di orchestrazione dei container Kubernetes per la gestione di modelli aperti per l'inferenza. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui si fa riferimento nei contenuti di Google Cloud , consulta Ruoli utente e attività comuni di GKE.

Per un'analisi dettagliata delle prestazioni e dei costi di gestione dei modelli per questi modelli aperti, puoi anche utilizzare lo strumento Guida rapida all'inferenza di GKE. Per scoprire di più, consulta la guida rapida di GKE Inference e il notebook Colab di accompagnamento.

Ottenere l'accesso al modello

Per accedere al modello tramite Hugging Face, devi disporre di un token Hugging Face.

Segui questi passaggi per generare un nuovo token se non ne hai già uno:

Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
Seleziona Nuovo token.
Specifica un Nome a tua scelta e un Ruolo con almeno l'autorizzazione Lettura.
Seleziona Genera un token.
Copia il token generato negli appunti.

Esegui il provisioning dell'ambiente di inferenza GKE

In questa sezione, esegui il deployment dell'infrastruttura necessaria per pubblicare il modello.

Avvia Cloud Shell

Questa guida utilizza Cloud Shell per eseguire i comandi. Cloud Shell viene fornito con gli strumenti necessari preinstallati, tra cui gcloud, kubectl e git.

Nella console Google Cloud , avvia un'istanza di Cloud Shell:

Apri Cloud Shell

Questa azione avvia una sessione nel riquadro inferiore della console Google Cloud .

Esegui il deployment dell'architettura di base

Per eseguire il provisioning del cluster GKE e delle risorse necessarie per accedere ai modelli da Hugging Face, segui questi passaggi:

In Cloud Shell, clona il seguente repository:

git clone https://github.com/GoogleCloudPlatform/accelerated-platforms --branch hf-model-tutorial && \
cd accelerated-platforms && \
export ACP_REPO_DIR="$(pwd)"

Imposta le variabili di ambiente:
```
export TF_VAR_platform_default_project_id=PROJECT_ID
export HF_TOKEN_READ=HF_TOKEN
```
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo Google Cloud ID progetto.
- HF_TOKEN: il token Hugging Face generato in precedenza.
Questa guida richiede Terraform versione 1.8.0 o successive. Cloud Shell ha Terraform v1.5.7 installato per impostazione predefinita.

Per aggiornare la versione di Terraform in Cloud Shell, puoi eseguire questo script. Questo script installa lo strumento terraform-switcher e apporta modifiche all'ambiente shell.
```
"${ACP_REPO_DIR}/tools/bin/install_terraform.sh"
source ~/.bashrc
```
Esegui il seguente script di deployment. Lo script di deployment abilita le API Google Cloud richieste e esegue il provisioning dell'infrastruttura necessaria per questa guida. Sono inclusi una nuova rete VPC, un cluster GKE con nodi privati e altre risorse di supporto. Il completamento dello script può richiedere diversi minuti.

Puoi gestire i modelli utilizzando le GPU in un cluster GKE Autopilot o Standard. Un cluster Autopilot offre un'esperienza Kubernetes completamente gestita. Per saperne di più sulla scelta della modalità operativa GKE più adatta ai tuoi workload, consulta Informazioni sulle modalità operative di GKE.
Autopilot
```
"${ACP_REPO_DIR}/platforms/gke/base/tutorials/hf-gpu-model/deploy-ap.sh"
```
Standard
```
"${ACP_REPO_DIR}/platforms/gke/base/tutorials/hf-gpu-model/deploy-standard.sh"
```
Al termine dello script, avrai un cluster GKE pronto per i carichi di lavoro di inferenza.

Esegui questo comando per impostare le variabili di ambiente dalla configurazione condivisa:

source "${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/terraform/_shared_config/scripts/set_environment_variables.sh"

Lo script di deployment crea un secret in Secret Manager per archiviare il token Hugging Face. Devi aggiungere manualmente il token a questo secret prima di eseguire il deployment del cluster. In Cloud Shell, esegui questo comando per aggiungere il token a Secret Manager.
```
echo ${HF_TOKEN_READ} | gcloud secrets versions add ${huggingface_hub_access_token_read_secret_manager_secret_name} \
    --data-file=- \
    --project=${huggingface_secret_manager_project_id}
```

Esegui il deployment di un modello aperto

Ora puoi scaricare ed eseguire il deployment del modello.

Imposta le variabili di ambiente per il modello di cui vuoi eseguire il deployment:

Gemma 3 27B-it

export ACCELERATOR_TYPE="h100"
export HF_MODEL_ID="google/gemma-3-27b-it"

Llama 4 Scout 17B-16E-Instruct

export ACCELERATOR_TYPE="h100"
export HF_MODEL_ID="meta-llama/llama-4-scout-17b-16e-instruct"

Qwen3 32B

export ACCELERATOR_TYPE="h100"
export HF_MODEL_ID="qwen/qwen3-32b"

gpt-oss 20B

export ACCELERATOR_TYPE="h100"
export HF_MODEL_ID="openai/gpt-oss-20b"

Per altre configurazioni, tra cui altre varianti di modello e tipi di GPU, consulta i manifest disponibili nel repository GitHub accelerated-platforms.

Recupera le variabili di ambiente dal deployment. Queste variabili di ambiente contengono i dettagli di configurazione necessari dell'infrastruttura che hai eseguito il provisioning.
```
source "${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/terraform/_shared_config/scripts/set_environment_variables.sh"
```

Esegui lo script seguente per configurare il job Kubernetes che scarica il modello in Cloud Storage:

"${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/kubernetes-manifests/model-download/configure_huggingface.sh"

Esegui il deployment del job di download del modello:

kubectl apply --kustomize "${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/kubernetes-manifests/model-download/huggingface"

Attendi il completamento del download. Monitora lo stato del job e quando COMPLETIONS è 1/1, premi Ctrl+C per uscire.

watch --color --interval 5 --no-title "kubectl --namespace=${huggingface_hub_downloader_kubernetes_namespace_name} get job/${HF_MODEL_ID_HASH}-hf-model-to-gcs

Esegui il deployment del carico di lavoro di inferenza nel cluster GKE.

"${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/kubernetes-manifests/online-inference-gpu/configure_deployment.sh"

kubectl apply --kustomize "${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/kubernetes-manifests/online-inference-gpu/vllm/${ACCELERATOR_TYPE}-${HF_MODEL_NAME}"

Testare il deployment

Attendi che il pod del server di inferenza sia pronto. Quando la colonna READY è 1/1, premi Ctrl+C per uscire.

watch --color --interval 5 --no-title "kubectl --namespace=${ira_online_gpu_kubernetes_namespace_name} get deployment/vllm-${ACCELERATOR_TYPE}-${HF_MODEL_NAME}"

Esegui lo script seguente per configurare il port forwarding e inviare una richiesta di esempio al modello. Questo esempio utilizza il formato del payload per un modello Gemma 3 27b-it.

kubectl --namespace=${ira_online_gpu_kubernetes_namespace_name} port-forward service/vllm-${ACCELERATOR_TYPE}-${HF_MODEL_NAME} 8000:8000 >/dev/null &
PF_PID=$!
curl http://127.0.0.1:8000/v1/chat/completions \
  --data '{
    "model": "/gcs/'${HF_MODEL_ID}'",
    "messages": [ { "role": "user", "content": "What is GKE?" } ]
  }' \
  --header "Content-Type: application/json" \
  --request POST \
  --show-error \
  --silent | jq
kill -9 ${PF_PID}

Dovresti visualizzare una risposta JSON del modello che risponde alla domanda.

Esegui la pulizia

Per evitare addebiti, elimina tutte le risorse che hai creato.

Elimina il workload di inferenza:

kubectl delete --ignore-not-found --kustomize "${ACP_REPO_DIR}/platforms/gke/base/use-cases/inference-ref-arch/kubernetes-manifests/online-inference-gpu/vllm/${ACCELERATOR_TYPE}-${HF_MODEL_NAME}"

Rimuovi il cluster GKE di base:

Autopilot

"${ACP_REPO_DIR}/platforms/gke/base/tutorials/hf-gpu-model/teardown-ap.sh"

Standard

"${ACP_REPO_DIR}/platforms/gke/base/tutorials/hf-gpu-model/teardown-standard.sh"

Passaggi successivi

Scopri di più sull'inferenza del modello di AI/ML su GKE.
Analizza le prestazioni e i costi dell'inferenza del modello con lo strumento GKE Inference Quickstart.
Esplora altri casi d'uso e pattern su GitHub basati su questa architettura.

Gestisci LLM aperti su GKE con un'architettura preconfigurata Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Ottenere l'accesso al modello

Esegui il provisioning dell'ambiente di inferenza GKE

Avvia Cloud Shell

Esegui il deployment dell'architettura di base

Autopilot

Standard

Esegui il deployment di un modello aperto

Gemma 3 27B-it

Llama 4 Scout 17B-16E-Instruct

Qwen3 32B

gpt-oss 20B

Testare il deployment

Esegui la pulizia

Autopilot

Standard

Passaggi successivi

Gestisci LLM aperti su GKE con un'architettura preconfigurata