Publique um LLM com TPUs no GKE com o JetStream e o PyTorch

Autopilot Padrão

Este guia mostra como publicar um modelo de linguagem (conteúdo extenso) (MDI/CE) usando unidades de processamento tensor (TPUs) no Google Kubernetes Engine (GKE) com o JetStream através do PyTorch. Neste guia, transfere os pesos dos modelos para o Cloud Storage e implementa-os num cluster do GKE Autopilot ou Standard através de um contentor que executa o JetStream.

Se precisar da escalabilidade, da resiliência e da rentabilidade oferecidas pelas funcionalidades do Kubernetes ao implementar o seu modelo no JetStream, este guia é um bom ponto de partida.

Este guia destina-se a clientes de IA generativa que usam o PyTorch, utilizadores novos ou existentes do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas que tenham interesse em usar capacidades de orquestração de contentores do Kubernetes para publicar LLMs.

Contexto

Ao publicar um MDG com TPUs no GKE com o JetStream, pode criar uma solução de publicação robusta e pronta para produção com todas as vantagens do Kubernetes gerido, incluindo rentabilidade, escalabilidade e maior disponibilidade. Esta secção descreve as tecnologias principais usadas neste tutorial.

Acerca das TPUs

As TPUs são circuitos integrados específicos da aplicação (ASICs) desenvolvidos pela Google e usados para acelerar a aprendizagem automática e os modelos de IA criados com frameworks como o TensorFlow, o PyTorch e o JAX.

Antes de usar as TPUs no GKE, recomendamos que conclua o seguinte percurso de aprendizagem:

1. Saiba mais sobre a disponibilidade da versão atual da TPU com a arquitetura do sistema Cloud TPU.
2. Saiba mais sobre as TPUs no GKE.

Este tutorial aborda a publicação de vários modelos de MDIs. O GKE implementa o modelo em nós TPUv5e de anfitrião único com topologias de TPU configuradas com base nos requisitos do modelo para publicar comandos com baixa latência.

Acerca do JetStream

O JetStream é uma framework de fornecimento de inferência de código aberto desenvolvida pela Google. O JetStream permite uma inferência de alto desempenho, com elevado débito e otimizada em função da memória em TPUs e GPUs. O JetStream oferece otimizações de desempenho avançadas, incluindo o processamento em lote contínuo, otimizações da cache KV e técnicas de quantização, para facilitar a implementação de LLMs. O JetStream permite a publicação de TPUs do PyTorch/XLA e JAX para alcançar um desempenho ótimo.

Criação de lotes contínua

O processamento em lote contínuo é uma técnica que agrupa dinamicamente os pedidos de inferência recebidos em lotes, reduzindo a latência e aumentando o débito.

Quantização da cache KV

A quantização da cache KV envolve a compressão da cache de chave-valor usada nos mecanismos de atenção, o que reduz os requisitos de memória.

Quantização de pesos Int8

A quantização de pesos Int8 reduz a precisão dos pesos do modelo de ponto flutuante de 32 bits para números inteiros de 8 bits, o que resulta num cálculo mais rápido e numa utilização de memória reduzida.

Para saber mais acerca destas otimizações, consulte os repositórios dos projetos JetStream PyTorch e JetStream MaxText.

Acerca do PyTorch

O PyTorch é um framework de aprendizagem automática de código aberto desenvolvido pela Meta e agora parte da Linux Foundation. O PyTorch oferece funcionalidades de alto nível, como o cálculo de tensores e redes neurais profundas.

Objetivos

1. Prepare um cluster do GKE Autopilot ou Standard com a topologia de TPU recomendada com base nas caraterísticas do modelo.
2. Implemente componentes do JetStream no GKE.
3. Obtenha e publique o seu modelo.
4. Publicar e interagir com o modelo publicado.

Arquitetura

Esta secção descreve a arquitetura do GKE usada neste tutorial. A arquitetura inclui um cluster do GKE Autopilot ou Standard que aprovisiona as TPUs e aloja os componentes do JetStream para implementar e publicar os modelos.

O diagrama seguinte mostra os componentes desta arquitetura:

Esta arquitetura inclui os seguintes componentes:

• Um cluster regional do GKE Autopilot ou Standard.
• Dois pools de nós de fatias de TPUs de anfitrião único que alojam a implementação do JetStream.
• O componente Service distribui o tráfego de entrada por todas as réplicas JetStream HTTP.
• JetStream HTTP é um servidor HTTP que aceita pedidos como um wrapper para o formato necessário do JetStream e envia-o para o cliente GRPC do JetStream.
• O JetStream-PyTorch é um servidor JetStream que realiza inferências com processamento em lote contínuo.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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, roles/resourcemanager.projectIamAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. 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.

  4. 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

  1. In the Google Cloud console, go to the IAM page.

     Aceder ao IAM
  2. Selecione o projeto.
  3. Clique em Conceder acesso.

  4. No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.

  5. Na lista Selecionar uma função, selecione uma função.
  6. Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
  7. Clique em Guardar.
  • Verifique se tem quota suficiente para oito chips TPU v5e PodSlice Lite. Neste tutorial, vai usar instâncias a pedido.
  • Crie um token do Hugging Face, se ainda não tiver um.

  Aceda ao modelo

  Aceda a vários modelos no Hugging Face para implementação no GKE

  Gemma 7B-it

  Para aceder ao modelo Gemma para implementação no GKE, tem de assinar primeiro o contrato de consentimento da licença.

  1. Aceda à página de consentimento do modelo Gemma no Hugging Face
  2. Inicie sessão no Hugging Face, caso ainda não o tenha feito.
  3. Reveja e aceite os Termos de Utilização do modelo.

  Llama 3 8B

  Para aceder ao modelo Llama 3 para implementação no GKE, tem de assinar primeiro o contrato de consentimento da licença.

  1. Aceda à página de consentimento do modelo Llama 3 no Hugging Face
  2. Inicie sessão no Hugging Face, caso ainda não o tenha feito.
  3. Reveja e aceite os Termos de Utilização do modelo.

  Prepare o 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:

  1. 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

  2. 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 CLUSTER_NAME=CLUSTER_NAME
     export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
     export NODE_LOCATION=NODE_LOCATION
     export CLUSTER_VERSION=CLUSTER_VERSION
     export BUCKET_NAME=BUCKET_NAME
     

     Substitua os seguintes valores:

     • PROJECT_ID: o seu Google Cloud ID do projeto.
     • CLUSTER_NAME: o nome do seu cluster do GKE.
     • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. A região tem de conter zonas onde os tipos de máquinas TPU v5e estão disponíveis (por exemplo, us-west1, us-west4, us-central1, us-east1, us-east5 ou europe-west4). Para clusters do Autopilot, certifique-se de que tem recursos zonais de TPU v5e suficientes para a região escolhida.
     • (Apenas para o cluster padrão) NODE_LOCATION: a zona onde os recursos de TPU estão disponíveis (por exemplo, us-west4-a). Para clusters do Autopilot, não precisa de especificar este valor.
     • CLUSTER_VERSION: a versão do GKE, que tem de suportar o tipo de máquina que quer usar. Tenha em atenção que a versão predefinida do GKE pode não ter disponibilidade para a TPU de destino. Para ver uma lista das versões mínimas do GKE disponíveis por tipo de máquina TPU, consulte o artigo Disponibilidade de TPUs no GKE.
     • BUCKET_NAME: o nome do seu contentor do Cloud Storage, usado para armazenar a cache de compilação do JAX.

  Crie e configure Google Cloud recursos

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

  Nota: pode ter de criar uma reserva de capacidade para a utilização de alguns aceleradores. Para saber como reservar e consumir recursos reservados, consulte o artigo Consumir recursos zonais reservados.

  Crie um cluster do GKE

  Pode publicar o Gemma em TPUs 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

  Crie um cluster do GKE Autopilot:

  gcloud container clusters create-auto CLUSTER_NAME \
      --project=PROJECT_ID \
      --location=CONTROL_PLANE_LOCATION \
      --cluster-version=CLUSTER_VERSION
  

  Substitua CLUSTER_VERSION pela versão do cluster adequada. Para um cluster do GKE Autopilot, use uma versão normal do canal de lançamento.

  Standard

  1. Crie um cluster padrão do GKE regional que use a Workload Identity Federation para o GKE:

     gcloud container clusters create CLUSTER_NAME \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --cluster-version=CLUSTER_VERSION \
         --workload-pool=PROJECT_ID.svc.id.goog \
         --location=CONTROL_PLANE_LOCATION
     

     A criação do cluster pode demorar vários minutos.

     Substitua CLUSTER_VERSION pela versão do cluster adequada.

  2. Crie um node pool da TPU v5e com uma topologia 2x4 e dois nós:

     gcloud container node-pools create tpu-nodepool \
       --cluster=CLUSTER_NAME \
       --machine-type=ct5lp-hightpu-8t \
       --project=PROJECT_ID \
       --num-nodes=2 \
       --location=CONTROL_PLANE_LOCATION \
       --node-locations=NODE_LOCATION
     

  Gere o seu token da CLI Hugging Face no Cloud Shell

  Gere um novo token do Hugging Face se ainda não tiver um:

  1. Clique em O seu perfil > Definições > Tokens de acesso.
  2. Clique em Novo token.
  3. Especifique um nome à sua escolha e uma função de, pelo menos, Read.
  4. Clique em Gerar um token.
  5. Edite as autorizações do seu token de acesso para ter acesso de leitura ao repositório do Hugging Face do seu modelo.
  6. Copie o token gerado para a área de transferência.

  Crie um segredo do Kubernetes para as credenciais do Hugging Face

  No Cloud Shell, faça o seguinte:

  1. Configure kubectl para comunicar com o cluster:

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

  2. Crie um segredo para armazenar as credenciais do Hugging Face:

     kubectl create secret generic huggingface-secret \
         --from-literal=HUGGINGFACE_TOKEN=HUGGINGFACE_TOKEN
     

     Substitua HUGGINGFACE_TOKEN pelo seu token do Hugging Face.

  Configure o acesso das suas cargas de trabalho através da federação de identidades de cargas de trabalho para o GKE

  Atribua uma conta de serviço do Kubernetes à aplicação e configure essa conta de serviço do Kubernetes para funcionar como uma conta de serviço do IAM.

  1. Crie uma conta de serviço do IAM para a sua aplicação:

     gcloud iam service-accounts create wi-jetstream
     

  2. Adicione uma associação de políticas do IAM para a sua conta de serviço do IAM para gerir o Cloud Storage:

     gcloud projects add-iam-policy-binding PROJECT_ID \
         --member "serviceAccount:wi-jetstream@PROJECT_ID.iam.gserviceaccount.com" \
         --role roles/storage.objectUser
     
     gcloud projects add-iam-policy-binding PROJECT_ID \
         --member "serviceAccount:wi-jetstream@PROJECT_ID.iam.gserviceaccount.com" \
         --role roles/storage.insightsCollectorService
     

  3. Permita que a conta de serviço do Kubernetes use a identidade da conta de serviço da IAM adicionando uma associação de políticas da IAM entre as duas contas de serviço. Esta associação permite que a conta de serviço do Kubernetes atue como a conta de serviço do IAM:

     gcloud iam service-accounts add-iam-policy-binding wi-jetstream@PROJECT_ID.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:PROJECT_ID.svc.id.goog[default/default]"
     

  4. Anotar a conta de serviço do Kubernetes com o endereço de email da conta de serviço do IAM:

     kubectl annotate serviceaccount default \
         iam.gke.io/gcp-service-account=wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
     

  Implemente o JetStream

  Implemente o contentor JetStream para publicar o seu modelo. Este tutorial usa manifestos de implementação 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.

  Guarde o seguinte manifesto como jetstream-pytorch-deployment.yaml:

  Gemma 7B-it

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: jetstream-pytorch-server
  spec:
    replicas: 2
    selector:
      matchLabels:
        app: jetstream-pytorch-server
    template:
      metadata:
        labels:
          app: jetstream-pytorch-server
      spec:
        nodeSelector:
          cloud.google.com/gke-tpu-topology: 2x4
          cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        containers:
        - name: jetstream-pytorch-server
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
          args:
          - --model_id=google/gemma-7b-it
          - --override_batch_size=30
          - --enable_model_warmup=True
          volumeMounts:
          - name: huggingface-credentials
            mountPath: /huggingface
            readOnly: true
          ports:
          - containerPort: 9000
          resources:
            requests:
              google.com/tpu: 8
            limits:
              google.com/tpu: 8
          startupProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            initialDelaySeconds: 90
            failureThreshold: 50
          livenessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
        - name: jetstream-http
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
          ports:
          - containerPort: 8000
        volumes:
        - name: huggingface-credentials
          secret:
            defaultMode: 0400
            secretName: huggingface-secret
  ---
  apiVersion: v1
  kind: Service
  metadata:
    name: jetstream-svc
  spec:
    selector:
      app: jetstream-pytorch-server
    ports:
    - protocol: TCP
      name: jetstream-http
      port: 8000
      targetPort: 8000

  Llama 3 8B

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: jetstream-pytorch-server
  spec:
    replicas: 2
    selector:
      matchLabels:
        app: jetstream-pytorch-server
    template:
      metadata:
        labels:
          app: jetstream-pytorch-server
      spec:
        nodeSelector:
          cloud.google.com/gke-tpu-topology: 2x4
          cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        containers:
        - name: jetstream-pytorch-server
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
          args:
          - --model_id=meta-llama/Meta-Llama-3-8B
          - --override_batch_size=30
          - --enable_model_warmup=True
          volumeMounts:
          - name: huggingface-credentials
            mountPath: /huggingface
            readOnly: true
          ports:
          - containerPort: 9000
          resources:
            requests:
              google.com/tpu: 8
            limits:
              google.com/tpu: 8
          startupProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            initialDelaySeconds: 90
            failureThreshold: 50
          livenessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
        - name: jetstream-http
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
          ports:
          - containerPort: 8000
        volumes:
        - name: huggingface-credentials
          secret:
            defaultMode: 0400
            secretName: huggingface-secret
  ---
  apiVersion: v1
  kind: Service
  metadata:
    name: jetstream-svc
  spec:
    selector:
      app: jetstream-pytorch-server
    ports:
    - protocol: TCP
      name: jetstream-http
      port: 8000
      targetPort: 8000

  O manifesto define as seguintes propriedades principais:

  • model_id: o nome do modelo da Hugging Face (google/gemma-7b-it, meta-llama/Meta-Llama-3-8B) (consulte os modelos suportados).
  • override_batch_size: o tamanho do lote de descodificação por dispositivo, em que um chip de TPU equivale a um dispositivo. Este valor tem como predefinição 30.
  • enable_model_warmup: esta definição ativa o aquecimento do modelo após o início do servidor de modelos. Este valor tem como predefinição False.

  Opcionalmente, pode definir estas propriedades:

  • max_input_length: o comprimento máximo da sequência de entrada. Este valor tem como predefinição 1024.
  • max_output_length: o comprimento máximo de descodificação de saída. O valor predefinido é 1024.
  • quantize_weights: se o ponto de verificação é quantizado. Este valor tem como predefinição 0; defina-o como 1 para ativar a quantização int8.
  • internal_jax_compilation_cache: o diretório para a cache de compilação do JAX. Este valor tem como predefinição ~/jax_cache; defina-o como gs://BUCKET_NAME/jax_cache para a colocação em cache remota.

  No manifesto, é configurada uma sondagem de arranque para garantir que o servidor do modelo é etiquetado como Ready após o carregamento do modelo e a conclusão do aquecimento. As sondas de atividade e prontidão estão configuradas para garantir o bom funcionamento do servidor do modelo.

  1. Aplique o manifesto:

     kubectl apply -f jetstream-pytorch-deployment.yaml
     

  2. Valide a implementação:

     kubectl get deployment
     

     O resultado é semelhante ao seguinte:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     jetstream-pytorch-server          0/2     2            0           ##s
     

     Para clusters do Autopilot, o aprovisionamento dos recursos de TPU necessários pode demorar alguns minutos.

  3. Veja os registos do servidor JetStream-PyTorch para verificar se os pesos do modelo foram carregados e se o aquecimento do modelo foi concluído. O servidor pode demorar alguns minutos a concluir esta operação.

     kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-pytorch-server
     

     O resultado é semelhante ao seguinte:

     Started jetstream_server....
     2024-04-12 04:33:37,128 - root - INFO - ---------Generate params 0 loaded.---------
     

  4. Verifique se a implementação está pronta:

     kubectl get deployment
     

     O resultado é semelhante ao seguinte:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     jetstream-pytorch-server          2/2     2            2           ##s
     

     O registo do ponto final healthcheck pode demorar alguns minutos.

  Publique o modelo

  Nesta secção, interage com o modelo.

  Configure o encaminhamento de portas

  Pode aceder à implementação do JetStream através do serviço ClusterIP que criou no passo anterior. Os serviços ClusterIP só são acessíveis a partir do cluster. Por conseguinte, para aceder ao serviço a partir do exterior do cluster, conclua os seguintes passos:

  Para estabelecer uma sessão de encaminhamento de portas, execute o seguinte comando:

  kubectl port-forward svc/jetstream-svc 8000:8000
  

  Interaja com o modelo através do curl

  1. Verifique se consegue aceder ao servidor HTTP JetStream abrindo um novo terminal e executando o seguinte comando:

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8000/generate \
     --data \
     '{
         "prompt": "What are the top 5 programming languages",
         "max_tokens": 200
     }'
     

     O pedido inicial pode demorar vários segundos a ser concluído devido ao aquecimento do modelo. O resultado é semelhante ao seguinte:

     {
         "response": " for data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its readability, extensive libraries (pandas, scikit-learn), and integration with other tools.\n- High demand for Python programmers in data science roles.\n\n**2. R:**\n- Popular choice for data analysis and visualization, particularly in academia and research.\n- Extensive libraries for statistical modeling and data wrangling.\n\n**3. Java:**\n- Enterprise-grade platform for data science, with strong performance and scalability.\n- Widely used in data mining and big data analytics.\n\n**4. SQL:**\n- Essential for data querying and manipulation, especially in relational databases.\n- Used for data analysis and visualization in various industries.\n\n**5. Scala:**\n- Scalable and efficient for big data processing and machine learning models.\n- Popular in data science for its parallelism and integration with Spark and Spark MLlib."
     }
     
     

  Concluiu com êxito o seguinte:

  1. Implementou o servidor de modelos JetStream-PyTorch no GKE com TPUs.
  2. Foram apresentadas e houve interação com o modelo.

  Observe o desempenho do modelo

  Para observar o desempenho do modelo, pode usar a integração do painel de controlo do JetStream 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 do JetStream, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas do JetStream, no seu cluster do GKE.

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

  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.

  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 os seguintes comandos e siga as instruções:

  gcloud container clusters delete CLUSTER_NAME --location=CONTROL_PLANE_LOCATION
  
  gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
  

  O que se segue?

  • Descubra como pode executar modelos Gemma no GKE e como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma GKE.
  • Saiba mais acerca das TPUs no GKE.
  • Explore o repositório do GitHub do JetStream.
  • Explore o Vertex AI Model Garden.