Gestisci un LLM con più GPU in GKE

Autopilot Standard

Questo tutorial mostra come eseguire il deployment e pubblicare un modello linguistico di grandi dimensioni (LLM) utilizzando più GPU su GKE per un'inferenza efficiente e scalabile. Crea un cluster GKE che utilizza più GPU L4 e prepara l'infrastruttura per gestire uno dei seguenti modelli:

• Llama 3 70b
• Mixtral 8x7b
• Falcon 40b

A seconda del formato dei dati del modello, il numero di GPU richiesto varia. In questo tutorial, ogni modello utilizza due GPU L4. Per saperne di più, consulta Calcolo della quantità di GPU.

Questo tutorial è rivolto a ingegneri di machine learning (ML), amministratori e operatori di piattaforme e a specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la pubblicazione di LLM. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui viene fatto riferimento nei contenuti di Google Cloud questa pagina, consulta Ruoli e attività comuni degli utenti GKE.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

• Modalità Autopilot e Standard
• Disponibilità della versione attuale della GPU
• GPU in GKE

Obiettivi

In questo tutorial:

1. Crea un cluster e i node pool.
2. Prepara il workload.
3. Esegui il deployment del workload.
4. Interagisci con l'interfaccia LLM.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

• Alcuni modelli hanno requisiti aggiuntivi. Assicurati di soddisfare i seguenti requisiti:

  • Per accedere ai modelli di Hugging Face, utilizza un token HuggingFace.
  • Per il modello Mixtral 8x7b, accetta le condizioni per il modello Mistral Mixtral.
  • Per il modello Llama 3 70b, assicurati di avere una licenza attiva per i modelli Meta Llama.
  Avviso: l'accesso e l'approvazione per il modello Llama potrebbero richiedere fino a tre giorni.

prepara l'ambiente

1. Nella console Google Cloud , avvia un'istanza Cloud Shell:
   Apri Cloud Shell

2. Imposta le variabili di ambiente predefinite:

   gcloud config set project PROJECT_ID
   gcloud config set billing/quota_project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export CONTROL_PLANE_LOCATION=us-central1
   

   Sostituisci PROJECT_ID con il tuo Google Cloud ID progetto.

   Nota: se l'istanza Cloud Shell si disconnette durante l'esecuzione del tutorial, ripeti il passaggio precedente.

Crea un cluster GKE e un pool di nodi

Puoi gestire LLM su GPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi workload, consulta Scegliere una modalità operativa GKE.

Autopilot

1. In Cloud Shell, esegui questo comando:

   gcloud container clusters create-auto l4-demo \
     --project=${PROJECT_ID} \
     --location=${CONTROL_PLANE_LOCATION} \
     --release-channel=rapid
   

   GKE crea un cluster Autopilot con nodi CPU e GPU come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.

2. Configura kubectl per comunicare con il cluster:

   gcloud container clusters get-credentials l4-demo --location=${CONTROL_PLANE_LOCATION}
   

Standard

1. In Cloud Shell, esegui questo comando per creare un cluster Standard che utilizza la federazione delle identità per i carichi di lavoro per GKE:

   gcloud container clusters create l4-demo \
     --location ${CONTROL_PLANE_LOCATION} \
     --workload-pool ${PROJECT_ID}.svc.id.goog \
     --enable-image-streaming \
     --node-locations=${CONTROL_PLANE_LOCATION}-a \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --machine-type n2d-standard-4 \
     --num-nodes 1 --min-nodes 1 --max-nodes 5 \
     --release-channel=rapid
   

   Nota: il flag --node-locations potrebbe dover essere modificato in base alla regione scelta. Controlla in quali zone sono disponibili le GPU L4 se modifichi la regione us-central1.

   La creazione del cluster potrebbe richiedere diversi minuti.

2. Esegui questo comando per creare un node pool per il tuo cluster:

   gcloud container node-pools create g2-standard-24 --cluster l4-demo \
     --location ${CONTROL_PLANE_LOCATION} \
     --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
     --machine-type g2-standard-24 \
     --enable-autoscaling --enable-image-streaming \
     --num-nodes=0 --min-nodes=0 --max-nodes=3 \
     --node-locations ${CONTROL_PLANE_LOCATION}-a,${CONTROL_PLANE_LOCATION}-c \
     --spot
   

   GKE crea le seguenti risorse per l'LLM:

   • Un cluster Standard pubblico.
   • Un pool di nodi con il tipo di macchina g2-standard-24 ridimensionato a 0 nodi. Non ti vengono addebitati costi per le GPU finché non avvii i pod che le richiedono. Questo pool di nodi esegue il provisioning di VM spot, che hanno un prezzo inferiore rispetto alle VM Compute Engine standard predefinite e non offrono alcuna garanzia di disponibilità. Puoi rimuovere il flag --spot da questo comando e il selettore di nodi cloud.google.com/gke-spot nella configurazione text-generation-inference.yaml per utilizzare le VM on demand.

3. Configura kubectl per comunicare con il cluster:

   gcloud container clusters get-credentials l4-demo --location=${CONTROL_PLANE_LOCATION}
   

Prepara il workload

Questa sezione mostra come configurare il workload in base al modello che vuoi utilizzare. Questo tutorial utilizza i deployment Kubernetes per eseguire il deployment del modello. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

Llama 3 70b

1. Imposta le variabili di ambiente predefinite:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Sostituisci HUGGING_FACE_TOKEN con il tuo token HuggingFace.

2. Crea un secret Kubernetes per il token HuggingFace:

   kubectl create secret generic l4-demo \
       --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Crea il seguente manifest di deployment text-generation-inference.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: meta-llama/Meta-Llama-3-70B-Instruct
           - name: NUM_SHARD
             value: "2"
           - name: MAX_INPUT_TOKENS
             value: "2048"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             # mountPath is set to /tmp as it's the path where the HUGGINGFACE_HUB_CACHE environment
             # variable in the TGI DLCs is set to instead of the default /data set within the TGI default image.
             # i.e. where the downloaded model from the Hub will be stored
             - mountPath: /tmp
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 150Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In questo manifest:

   • NUM_SHARD deve essere 2 perché il modello richiede due GPU NVIDIA L4.
   • QUANTIZE è impostato su bitsandbytes-nf4, il che significa che il modello viene caricato a 4 bit anziché a 32 bit. Ciò consente a GKE di ridurre la quantità di memoria GPU necessaria e migliora la velocità di inferenza. Tuttavia, l'accuratezza del modello può diminuire. Per scoprire come calcolare le GPU da richiedere, consulta Calcolo della quantità di GPU.

4. Applica il manifest:

   kubectl apply -f text-generation-inference.yaml
   

   L'output è simile al seguente:

   deployment.apps/llm created
   

5. Verifica lo stato del modello:

   kubectl get deploy
   

   L'output è simile al seguente:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           20m
   

6. Visualizza i log del deployment in esecuzione:

   kubectl logs -l app=llm
   

   L'output è simile al seguente:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Mixtral 8x7b

1. Imposta le variabili di ambiente predefinite:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Sostituisci HUGGING_FACE_TOKEN con il tuo token HuggingFace.

2. Crea un secret Kubernetes per il token HuggingFace:

   kubectl create secret generic l4-demo \
       --from-literal=HUGGING_FACE_TOKEN=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Crea il seguente manifest di deployment text-generation-inference.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
           resources:
             requests:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: mistralai/Mixtral-8x7B-Instruct-v0.1
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN          
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             # mountPath is set to /tmp as it's the path where the HF_HOME environment
             # variable in the TGI DLCs is set to instead of the default /data set within the TGI default image.
             # i.e. where the downloaded model from the Hub will be stored
             - mountPath: /tmp
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 100Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In questo manifest:

   • NUM_SHARD deve essere 2 perché il modello richiede due GPU NVIDIA L4.
   • QUANTIZE è impostato su bitsandbytes-nf4, il che significa che il modello viene caricato a 4 bit anziché a 32 bit. Ciò consente a GKE di ridurre la quantità di memoria GPU necessaria e migliora la velocità di inferenza. Tuttavia, ciò potrebbe ridurre l'accuratezza del modello. Per scoprire come calcolare il numero di GPU da richiedere, consulta Calcolo della quantità di GPU.

4. Applica il manifest:

   kubectl apply -f text-generation-inference.yaml
   

   L'output è simile al seguente:

   deployment.apps/llm created
   

5. Verifica lo stato del modello:

   watch kubectl get deploy
   

   Quando il deployment è pronto, l'output è simile al seguente:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

   Per uscire dallo smartwatch, digita CTRL + C.

6. Visualizza i log del deployment in esecuzione:

   kubectl logs -l app=llm
   

   L'output è simile al seguente:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Falcon 40b

1. Crea il seguente manifest di deployment text-generation-inference.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.1-4.ubuntu2204.py310
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: tiiuae/falcon-40b-instruct
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             # mountPath is set to /data as it's the path where the HUGGINGFACE_HUB_CACHE environment
             # variable points to in the TGI container image i.e. where the downloaded model from the Hub will be
             # stored
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 175Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In questo manifest:

   • NUM_SHARD deve essere 2 perché il modello richiede due GPU NVIDIA L4.
   • QUANTIZE è impostato su bitsandbytes-nf4, il che significa che il modello viene caricato a 4 bit anziché a 32 bit. Ciò consente a GKE di ridurre la quantità di memoria GPU necessaria e migliora la velocità di inferenza. Tuttavia, l'accuratezza del modello può diminuire. Per scoprire come calcolare il numero di GPU da richiedere, consulta Calcolo della quantità di GPU.

2. Applica il manifest:

   kubectl apply -f text-generation-inference.yaml
   

   L'output è simile al seguente:

   deployment.apps/llm created
   

3. Verifica lo stato del modello:

   watch kubectl get deploy
   

   Quando il deployment è pronto, l'output è simile al seguente:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

   Per uscire dallo smartwatch, digita CTRL + C.

4. Visualizza i log del deployment in esecuzione:

   kubectl logs -l app=llm
   

   L'output è simile al seguente:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Crea un servizio di tipo ClusterIP

Esporre i pod internamente al cluster in modo che possano essere rilevati e accessibili da altre applicazioni.

1. Crea il seguente manifest llm-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: llm
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Applica il manifest:

   kubectl apply -f llm-service.yaml
   

Esegui il deployment di un'interfaccia di chat

Utilizza Gradio per creare un'applicazione web che ti consenta di interagire con il tuo modello. Gradio è una libreria Python che include un wrapper ChatInterface che crea interfacce utente per chatbot.

Llama 3 70b

1. Crea un file denominato gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     replicas: 1
     selector:
       matchLabels:
         app: gradio
     template:
       metadata:
         labels:
           app: gradio
       spec:
         containers:
         - name: gradio
           image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "meta-llama/Meta-Llama-3-70B-Instruct"
           - name: USER_PROMPT
             value: "<|begin_of_text|><|start_header_id|>user<|end_header_id|> prompt <|eot_id|><|start_header_id|>assistant<|end_header_id|>"
           - name: SYSTEM_PROMPT
             value: "prompt <|eot_id|>"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860
   

2. Applica il manifest:

   kubectl apply -f gradio.yaml
   

3. Trova l'indirizzo IP esterno del servizio:

   kubectl get svc
   

   L'output è simile al seguente:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Copia l'indirizzo IP esterno dalla colonna EXTERNAL-IP.

5. Visualizza l'interfaccia del modello dal browser web utilizzando l'indirizzo IP esterno con la porta esposta:

   http://EXTERNAL_IP
   

Mixtral 8x7b

1. Crea un file denominato gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     replicas: 1
     selector:
       matchLabels:
         app: gradio
     template:
       metadata:
         labels:
           app: gradio
       spec:
         containers:
         - name: gradio
           image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "mixtral-8x7b"
           - name: USER_PROMPT
             value: "[INST] prompt [/INST]"
           - name: SYSTEM_PROMPT
             value: "prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860
   

2. Applica il manifest:

   kubectl apply -f gradio.yaml
   

3. Trova l'indirizzo IP esterno del servizio:

   kubectl get svc
   

   L'output è simile al seguente:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Copia l'indirizzo IP esterno dalla colonna EXTERNAL-IP.

5. Visualizza l'interfaccia del modello dal browser web utilizzando l'indirizzo IP esterno con la porta esposta:

   http://EXTERNAL_IP
   

Falcon 40b

1. Crea un file denominato gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     replicas: 1
     selector:
       matchLabels:
         app: gradio
     template:
       metadata:
         labels:
           app: gradio
       spec:
         containers:
         - name: gradio
           image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "falcon-40b-instruct"
           - name: USER_PROMPT
             value: "User: prompt"
           - name: SYSTEM_PROMPT
             value: "Assistant: prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860
   

2. Applica il manifest:

   kubectl apply -f gradio.yaml
   

3. Trova l'indirizzo IP esterno del servizio:

   kubectl get svc
   

   L'output è simile al seguente:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Copia l'indirizzo IP esterno dalla colonna EXTERNAL-IP.

5. Visualizza l'interfaccia del modello dal browser web utilizzando l'indirizzo IP esterno con la porta esposta:

   http://EXTERNAL_IP
   

Operazione riuscita: a questo punto, hai eseguito il deployment di un LLM utilizzando le GPU L4 in GKE.

Calcolare la quantità di GPU

Il numero di GPU dipende dal valore del flag QUANTIZE. In questo tutorial, QUANTIZE è impostato su bitsandbytes-nf4, il che significa che il modello viene caricato in 4 bit.

Un modello con 70 miliardi di parametri richiederebbe un minimo di 40 GB di memoria GPU, che equivale a 70 miliardi di volte 4 bit (70 miliardi x 4 bit= 35 GB) e considera un overhead di 5 GB. In questo caso, una singola GPU L4 non avrebbe memoria sufficiente. Pertanto, gli esempi di questo tutorial utilizzano due GPU L4 di memoria (2 x 24 = 48 GB). Questa configurazione è sufficiente per eseguire Falcon 40b o Llama 3 70b nelle GPU L4.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il cluster

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse che hai creato in questa guida, elimina il cluster GKE:

gcloud container clusters delete l4-demo --location ${CONTROL_PLANE_LOCATION}

Passaggi successivi

• Scopri di più sulle VM G2 con GPU NVIDIA L4
• Addestra un modello con GPU in modalità GKE Standard