Esta página foi traduzida pela API Cloud Translation.

Publique modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face

Autopilot Padrão

Este tutorial mostra como implementar e publicar modelos de linguagem (conteúdo extenso) (MDI/CE) usando GPUs no Google Kubernetes Engine (GKE) com a framework de publicação Text Generation Inference (TGI) da Hugging Face. Este tutorial fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado que executa o TGI no GKE. Também configura o GKE para carregar os pesos do Gemma 2B, 9B e 27B a partir do Hugging Face.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA que tenham interesse em usar as capacidades de orquestração de contentores do Kubernetes para fornecer GMLs no hardware de GPU H100, A100 e L4. Para saber mais sobre as funções comuns e as tarefas de exemplo que referimos no conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE. Google Cloud

Se precisar de uma plataforma de IA gerida unificada para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.

Antes de ler esta página, certifique-se de que conhece o seguinte:

Contexto

Esta secção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa leves e disponíveis abertamente, lançados ao abrigo de uma licença aberta. Estes modelos de IA estão disponíveis para execução nas suas aplicações, hardware, dispositivos móveis ou serviços alojados.

Neste guia, apresentamos os seguintes modelos:

Gemma para geração de texto, também pode otimizar estes modelos para se especializarem na realização de tarefas específicas.
O CodeGemma é uma coleção de modelos poderosos e leves que podem realizar uma variedade de tarefas de programação, como preenchimento de código, geração de código, compreensão da linguagem natural, raciocínio matemático e seguimento de instruções.

Para saber mais, consulte a documentação do Gemma.

GPUs

As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

Text Generation Inference (TGI)

O TGI é o conjunto de ferramentas da Hugging Face para implementar e disponibilizar MDIs. A TGI permite a geração de texto de alto desempenho para MDIs de código aberto populares, incluindo o Gemma. O TGI inclui funcionalidades como:

Implementação de transformadores otimizada com Flash Attention e PagedAttention
Processamento em lote contínuo para melhorar o débito geral da publicação
Paralelismo de tensores para uma inferência mais rápida em várias GPUs

Para saber mais, consulte a documentação da TGI.

Objetivos

Prepare o seu ambiente com um cluster do GKE no modo Autopilot.
Implemente o TGI no seu cluster.
Use a TGI para publicar o modelo Gemma 2 através do curl e de uma interface de chat Web.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

Check for the roles

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

Grant the roles

In the Google Cloud console, go to the IAM page.
Aceder ao IAM
Selecione o projeto.
Clique em Conceder acesso.
No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.
Na lista Selecionar uma função, selecione uma função.
Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
Clique em Guardar.

Crie uma conta Hugging Face, se ainda não tiver uma.
Certifique-se de que o seu projeto tem quota suficiente para GPUs L4. Para saber mais, consulte os artigos Acerca das GPUs e Quotas de atribuição.

Aceda ao modelo

Para aceder aos modelos Gemma para implementação no GKE, primeiro tem de assinar o contrato de consentimento de licença e, em seguida, gerar um token de acesso do Hugging Face.

Tem de assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

Aceda à página de consentimento do modelo em Kaggle.com.
Valide o consentimento através da sua conta do Hugging Face.
Aceite os termos do modelo.

Gere um token de acesso

Para aceder ao modelo através do Hugging Face, precisa de um token do Hugging Face.

Siga estes passos para gerar um novo token se ainda não tiver um:

Clique em O seu perfil > Definições > Tokens de acesso.
Selecione Novo token.
Especifique um nome à sua escolha e uma função de, pelo menos, Read.
Selecione Gerar um token.
Copie o token gerado para a área de transferência.

Prepare o seu ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell vem pré-instalado com o software de que precisa para este tutorial, incluindo o kubectl e a CLI gcloud.

Para configurar o seu ambiente com o Cloud Shell, siga estes passos:

Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud
Defina as variáveis de ambiente predefinidas:
```
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=CONTROL_PLANE_LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export HF_TOKEN=HF_TOKEN
```
Substitua os seguintes valores:
- PROJECT_ID: o seu Google Cloud ID do projeto.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.
- HF_TOKEN: o token do Hugging Face que gerou anteriormente.

Crie e configure Google Cloud recursos

Siga estas instruções para criar os recursos necessários.

Crie um cluster e um node pool do GKE

Pode publicar o Gemma em GPUs num cluster do GKE Autopilot ou Standard. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No Cloud Shell, execute o seguinte comando:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid

Substitua os seguintes valores:

PROJECT_ID: o seu Google Cloud ID do projeto.
CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
CLUSTER_NAME: o nome do cluster.

O GKE cria um cluster do Autopilot com nós de CPU e GPU, conforme solicitado pelas cargas de trabalho implementadas.

Standard

No Cloud Shell, execute o seguinte comando para criar um cluster Standard:
```
gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --num-nodes=1
```
Substitua os seguintes valores:
- PROJECT_ID: o seu Google Cloud ID do projeto.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.
A criação do cluster pode demorar vários minutos.

Para criar um node pool para o seu cluster com o tamanho do disco adequado, execute o seguinte comando:

Gemma 2 2B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --node-locations=CONTROL_PLANE_LOCATION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-8 \
    --num-nodes=1

O GKE cria um único node pool que contém uma GPU L4 para cada nó.

Gemma 2 9B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --node-locations=CONTROL_PLANE_LOCATION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-24 \
    --num-nodes=1

O GKE cria um único node pool que contém duas GPUs L4 para cada nó.

Gemma 2 27B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --node-locations=CONTROL_PLANE_LOCATION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-48 \
    --num-nodes=1 \
    --disk-size=180

O GKE cria um único node pool com quatro GPUs L4 para cada nó.

Crie um segredo do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

Configure kubectl para comunicar com o cluster:

gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Crie um segredo do Kubernetes que contenha o token do Hugging Face:

kubectl create secret generic hf-secret \
    --from-literal=hf_api_token=HF_TOKEN \
    --dry-run=client -o yaml | kubectl apply -f -

Substitua HF_TOKEN pelo token do Hugging Face que gerou anteriormente.

Implemente a TGI

Nesta secção, implementa o contentor TGI para publicar o modelo Gemma que quer usar. Para implementar o modelo, este tutorial usa implementações do Kubernetes. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.

Gemma 2 2B-it

Siga estas instruções para implementar o modelo otimizado para instruções Gemma 2B.

Crie o seguinte manifesto tgi-2-2b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-2b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '1'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-2b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplique o manifesto:
```
kubectl apply -f tgi-2-2b-it.yaml
```

Gemma 2 de 9 mil milhões de parâmetros

Siga estas instruções para implementar o modelo ajustado por instruções Gemma 9B.

Crie o seguinte manifesto tgi-2-9b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-9b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "4"
            memory: "30Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "4"
            memory: "30Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "2"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '2'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-9b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplique o manifesto:
```
kubectl apply -f tgi-2-9b-it.yaml
```

Gemma 2 de 27 mil milhões de parâmetros

Siga estas instruções para implementar o modelo otimizado para instruções Gemma 2 27B.

Crie o seguinte manifesto tgi-2-27b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-27b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "10"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "4"
          limits:
            cpu: "10"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "4"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '4'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-27b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplique o manifesto:
```
kubectl apply -f tgi-2-27b-it.yaml
```

CodeGemma 7B-it

Siga estas instruções para implementar o modelo otimizado para instruções CodeGemma 7B.

Crie o seguinte manifesto tgi-codegemma-1.1-7b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-7b-it
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Aplique o manifesto:

kubectl apply -f tgi-codegemma-1.1-7b-it.yaml

Publique o modelo

Nesta secção, interage com o modelo.

Configure o encaminhamento de portas

Execute o seguinte comando para configurar o encaminhamento de portas para o modelo:

kubectl port-forward service/llm-service 8000:8000

O resultado é semelhante ao seguinte:

Forwarding from 127.0.0.1:8000 -> 8000

Interaja com o modelo através do curl

Esta secção mostra como pode realizar um teste de verificação de compilação básico para validar os modelos pré-treinados ou ajustados por instruções implementados. Para simplificar, esta secção descreve a abordagem de testes com os modelos Gemma 2 com ajuste fino de instruções e CodeGemma.

Gemma 2

Numa nova sessão de terminal, use curl para conversar com o seu modelo:

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

A saída seguinte mostra um exemplo da resposta do modelo:

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

Numa nova sessão de terminal, use curl para conversar com o seu modelo:

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

A saída seguinte mostra um exemplo da resposta do modelo:

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

(Opcional) Interagir com o modelo através de uma interface de chat do Gradio

Nesta secção, cria uma aplicação de chat Web que lhe permite interagir com o seu modelo otimizado para instruções. Para simplificar, esta secção descreve apenas a abordagem de testes com o modelo 2B-it.

O Gradio é uma biblioteca Python que tem um wrapper ChatInterface que cria interfaces do utilizador para chatbots.

Implemente a interface do chat

No Cloud Shell, guarde o seguinte manifesto como gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  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: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 7860
  type: ClusterIP

Aplique o manifesto:
```
kubectl apply -f gradio.yaml
```

Aguarde até que a implementação esteja disponível:

kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Use a interface de chat

No Cloud Shell, execute o seguinte comando:
```
kubectl port-forward service/gradio 8080:8080
```
Isto cria um encaminhamento de porta do Cloud Shell para o serviço Gradio.
Clique no botão Pré-visualização Web, que se encontra na parte superior direita da barra de tarefas do Cloud Shell. Clique em Pré-visualizar na porta 8080. É aberto um novo separador no navegador.
Interaja com o Gemma através da interface de chat do Gradio. Adicione uma mensagem e clique em Enviar.

Resolver problemas

Se receber a mensagem Empty reply from server, é possível que o contentor não tenha terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagem Connected, que indica que o modelo está pronto para publicação.
Se vir Connection refused, verifique se o encaminhamento de portas está ativo.

Observe o desempenho do modelo

Para observar o desempenho do modelo, pode usar a integração do painel de controlo da TGI no Cloud Monitoring. Com este painel de controlo, pode ver métricas de desempenho críticas, como o débito de tokens, a latência de pedidos e as taxas de erro.

Para usar o painel de controlo da TGI, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas da TGI, no seu cluster do GKE. Por predefinição, o TGI expõe métricas no formato Prometheus; não precisa de instalar um exportador adicional.

Em seguida, pode ver as métricas através do painel de controlo do TGI. Para obter informações sobre como usar o serviço gerido do Google Cloud para Prometheus para recolher métricas do seu modelo, consulte as orientações de observabilidade do TGI na documentação do Cloud Monitoring.

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

Elimine os recursos implementados

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos que criou neste guia, execute o seguinte comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

O que se segue?

Saiba mais acerca das GPUs no GKE.
Saiba como usar o Gemma com o TGI noutros aceleradores, incluindo GPUs A100 e H100, consultando o código de exemplo no GitHub.
Saiba como implementar cargas de trabalho de GPU no Autopilot.
Saiba como implementar cargas de trabalho de GPU no Standard.
Explore a documentação da TGI.
Explore o Vertex AI Model Garden.
Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.