Como implantar modelos abertos no GKE

1. Introdução

Visão geral

O objetivo deste laboratório é oferecer experiência prática na implantação de um modelo aberto no Google Cloud, progredindo de uma configuração local simples para uma implantação de nível de produção no Google Kubernetes Engine (GKE). Você vai aprender a usar diferentes ferramentas adequadas para cada estágio do ciclo de vida de desenvolvimento.

O laboratório segue este caminho:

  • Prototipagem rápida: primeiro, você vai executar um modelo com o Ollama localmente para ver como é fácil começar.
  • Implantação de produção: por fim, você vai implantar o modelo no Autopilot do GKE usando o Ollama como um mecanismo de disponibilização escalonável.

Entender modelos abertos

Atualmente, o termo "modelo aberto" geralmente se refere a um modelo de machine learning generativo que está disponível publicamente para download e uso de todos. Isso significa que a arquitetura do modelo e, mais importante, os parâmetros treinados ou "pesos" são liberados publicamente.

Essa transparência oferece várias vantagens em relação aos modelos fechados, que normalmente são acessados apenas por uma API restritiva:

  • Insight: desenvolvedores e pesquisadores podem analisar o funcionamento interno do modelo.
  • Personalização: os usuários podem adaptar o modelo para tarefas específicas por meio de um processo chamado ajuste fino.
  • Inovação: capacita a comunidade a criar aplicativos novos e inovadores com base em modelos poderosos.

A contribuição do Google e a família Gemma

O Google é um colaborador fundamental do movimento de IA de código aberto há muitos anos. A arquitetura revolucionária do Transformer, introduzida no artigo de 2017 "Attention Is All You Need", é a base de quase todos os modelos de linguagem grandes modernos. Isso foi seguido por modelos abertos marcantes, como BERT, T5 e o Flan-T5 ajustado por instrução, cada um deles ultrapassando os limites do que era possível e impulsionando a pesquisa e o desenvolvimento em todo o mundo.

Com base nesse histórico de inovação aberta, o Google apresentou a família de modelos Gemma. Os modelos Gemma são criados com a mesma pesquisa e tecnologia usadas para os modelos Gemini poderosos de código fechado, mas são disponibilizados com pesos abertos. Para os clientes do Google Cloud, isso oferece uma combinação poderosa de tecnologia de ponta e a flexibilidade do código aberto, permitindo que eles controlem o ciclo de vida do modelo, façam a integração com um ecossistema diversificado e busquem uma estratégia multicloud.

Destaque para o Gemma 3

Neste laboratório, vamos nos concentrar no Gemma 3, a geração mais recente e avançada dessa família. Os modelos Gemma 3 são leves, mas de última geração, projetados para serem executados com eficiência em uma única GPU ou até mesmo em uma CPU.

  • Desempenho e tamanho: os modelos Gemma 3 são leves, mas de última geração, projetados para serem executados com eficiência em uma única GPU ou até mesmo em uma CPU. Eles oferecem qualidade superior e desempenho de última geração (SOTA, na sigla em inglês) para o tamanho deles.
  • Modalidade: são multimodais, capazes de processar entradas de texto e imagem para gerar saída de texto.
  • Principais recursos: o Gemma 3 tem uma janela de contexto grande de 128 mil e oferece suporte a mais de 140 idiomas.
  • Casos de uso: esses modelos são adequados para várias tarefas, incluindo respostas a perguntas, resumos e raciocínio.

Terminologia importante

Ao trabalhar com modelos abertos, você vai encontrar alguns termos comuns:

  • O pré-treinamento envolve o treinamento de um modelo em um conjunto de dados massivo e diversificado para aprender padrões de linguagem gerais. Esses modelos são essencialmente máquinas de preenchimento automático poderosas.
  • O ajuste de instrução ajusta um modelo pré-treinado para seguir melhor instruções e comandos específicos. Esses são os modelos que "sabem conversar".
  • Variantes de modelo: os modelos abertos normalmente são lançados em vários tamanhos (por exemplo, o Gemma 3 tem versões de parâmetros de 1B, 4B, 12B e 27B) e variantes, como ajustados por instrução (-it), pré-treinados ou quantizados para eficiência.
  • Necessidades de recursos: os modelos de linguagem grandes são grandes e exigem recursos de computação significativos para serem hospedados. Embora possam ser executados localmente, a implantação deles na nuvem oferece um valor significativo, especialmente quando otimizados para desempenho e escalonabilidade com ferramentas como o Ollama.

Por que usar o GKE para disponibilizar modelos abertos?

Este laboratório orienta você desde a execução de modelos locais simples até uma implantação de produção em grande escala no Google Kubernetes Engine (GKE). Embora ferramentas como o Ollama sejam excelentes para prototipagem rápida, os ambientes de produção têm um conjunto exigente de requisitos que o GKE está em uma posição única para atender.

Para aplicativos de IA em grande escala, você precisa de mais do que apenas um modelo em execução. É necessário uma infraestrutura de disponibilização resiliente, escalonável e eficiente. O GKE fornece essa base. Veja quando e por que escolher o GKE:

  • Gerenciamento simplificado com o Autopilot: o Autopilot do GKE gerencia a infraestrutura para você. Você se concentra na configuração do aplicativo, e o Autopilot provisiona e dimensiona os nós automaticamente.
  • Alto desempenho e escalonabilidade: processe tráfego exigente e variável com o escalonamento automático do GKE. Isso garante que o aplicativo possa oferecer alta capacidade de processamento com baixa latência, escalonando para cima ou para baixo conforme necessário.
  • Custo-benefício em escala: gerencie recursos com eficiência. O GKE pode reduzir as cargas de trabalho a zero para evitar o pagamento de recursos ociosos, e você pode aproveitar as VMs spot para reduzir significativamente os custos de cargas de trabalho de inferência sem estado.
  • Portabilidade e ecossistema avançado: evite a dependência de um único fornecedor com uma implantação portátil baseada no Kubernetes. O GKE também oferece acesso ao vasto ecossistema do Cloud Native (CNCF) para as melhores ferramentas de monitoramento, registro e segurança.

Em resumo, você migra para o GKE quando o aplicativo de IA está pronto para produção e exige uma plataforma criada para escala, desempenho e maturidade operacional.

O que você vai aprender

Neste laboratório, você aprenderá a fazer o seguinte:

  • Executar um modelo aberto localmente com o Ollama.
  • Implantar um modelo aberto no Google Kubernetes Engine (GKE) Autopilot com o Ollama para disponibilização.
  • Entender a progressão de frameworks de desenvolvimento local para uma arquitetura de disponibilização de nível de produção no GKE.

2. Configurar o projeto

Conta do Google

Se você ainda não tiver uma Conta do Google pessoal, crie uma Conta do Google.

Use uma conta pessoal em vez de uma conta escolar ou do trabalho.

Fazer login no console do Google Cloud

Faça login no console do Google Cloud usando uma Conta do Google pessoal.

Ativar faturamento

Configurar uma conta de faturamento pessoal

Se você configurou o faturamento usando créditos do Google Cloud, pule esta etapa.

Para configurar uma conta de faturamento pessoal, acesse este link para ativar o faturamento no console do Cloud.

Algumas observações:

  • A conclusão deste laboratório custa menos de US $1 em recursos do Cloud.
  • Siga as etapas no final deste laboratório para excluir recursos e evitar mais cobranças.
  • Novos usuários estão qualificados para o programa de US$300 de avaliação sem custos.

Criar um projeto (opcional)

Se você não tiver um projeto atual que gostaria de usar para este laboratório, crie um novo projeto aqui.

3. Abrir editor do Cloud Shell

  1. Clique neste link para navegar diretamente até o editor do Cloud Shell.
  2. Se for solicitado a autorizar a qualquer momento, clique em Autorizar para continuar.Clique para autorizar o Cloud Shell
  3. Se o terminal não aparecer na parte de baixo da tela, abra-o:
    • Clique em Visualizar.
    • Clique em TerminalAbrir um novo terminal no editor do Cloud Shell.
  4. No terminal, defina o projeto com este comando:
    gcloud config set project [PROJECT_ID]
    • Exemplo:
      gcloud config set project lab-project-id-example
    • Se você não se lembrar do ID do projeto, liste todos os IDs com:
      gcloud projects list
      Definir o ID do projeto no terminal do Editor do Cloud Shell
  5. Você vai receber esta mensagem:
    Updated property [core/project].

4. Executar o Gemma com o Ollama

Seu primeiro objetivo é executar o Gemma 3 o mais rápido possível em um ambiente de desenvolvimento. Você vai usar o Ollama, uma ferramenta que simplifica muito a execução de modelos de linguagem grandes localmente. Esta tarefa mostra a maneira mais simples de começar a experimentar um modelo aberto.

Ollama é uma ferramenta de código aberto sem custo financeiro que permite aos usuários executar modelos generativos (modelos de linguagem grandes, modelos de linguagem de visão e muito mais) localmente no próprio computador. Ele simplifica o processo de acesso e interação com esses modelos, tornando-os mais acessíveis e permitindo que os usuários trabalhem com eles de forma privada.

Instalar e executar o Ollama

Agora, você está pronto para instalar o Ollama, fazer o download do modelo Gemma 3 e interagir com ele na linha de comando.

  1. No terminal do Cloud Shell, faça o download e instale o Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
    Esse comando faz o download do Ollama, instala e inicia o serviço do Ollama.
  2. Inicie o serviço do Ollama em segundo plano:
    ollama serve &
  3. Extraia (faça o download) do modelo Gemma 3 1B com o Ollama:
    ollama pull gemma3:1b
  4. Execute o modelo localmente:
    ollama run gemma3:1b
    O comando ollama run apresenta um comando (>>>) para você fazer perguntas ao modelo.
  5. Teste o modelo com uma pergunta. Por exemplo, digite Why is the sky blue? e pressione ENTER. Uma resposta semelhante a esta vai aparecer:
    >>> Why is the sky blue?
Okay, let's break down why the sky is blue – it's a fascinating phenomenon related to how light interacts with the Earth's atmosphere.
Here's the explanation:

**1. Sunlight and Colors:**

* Sunlight appears white, but it's actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet).
Think of a prism splitting sunlight.

**2. Rayleigh Scattering:**

* As sunlight enters the Earth's atmosphere...
...
  6. Para sair do comando do Ollama no terminal, digite /bye e pressione ENTER.

Usar o SDK do OpenAI com o Ollama

Agora que o serviço do Ollama está em execução, é possível interagir com ele de forma programática. Você vai usar o SDK do OpenAI Python, que é compatível com a API exposta pelo Ollama.

  1. No terminal do Cloud Shell, crie e ative um ambiente virtual usando o uv. Isso garante que as dependências do projeto não entrem em conflito com o Python do sistema.
    uv venv --python 3.14
source .venv/bin/activate
  2. No terminal, instale o SDK do OpenAI:
    uv pip install openai
  3. Crie um arquivo chamado ollama_chat.py inserindo no terminal:
    cloudshell edit ollama_chat.py
  4. Cole o código Python a seguir em ollama_chat.py. Esse código envia uma solicitação para o servidor Ollama local.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama', # required by OpenAI SDK, but not used by Ollama
)

response = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
)
print(response.choices[0].message.content)
  5. Execute o script no terminal:
    python3 ollama_chat.py
    Após alguns segundos, você vai receber uma resposta semelhante à que recebeu na linha de comando.
  6. Para testar o modo de transmissão, crie outro arquivo chamado ollama_stream.py executando o seguinte no terminal:
    cloudshell edit ollama_stream.py
  7. Cole o conteúdo a seguir no arquivo ollama_stream.py. Observe o parâmetro stream=True na solicitação. Isso permite que o modelo retorne tokens assim que forem gerados.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama',
)

stream = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()
  8. Execute o script de transmissão no terminal:
    python3 ollama_stream.py
    A resposta vai aparecer token por token.

A transmissão é um recurso útil para criar uma boa experiência do usuário em aplicativos interativos, como chatbots. Em vez de fazer o usuário esperar que a resposta inteira seja gerada, a transmissão mostra a resposta token por token à medida que ela é criada. Isso fornece feedback imediato e torna o aplicativo muito mais responsivo.

O que você aprendeu: executar modelos abertos com o Ollama

Você executou um modelo aberto usando o Ollama. Você viu como é simples fazer o download de um modelo poderoso como o Gemma 3 e interagir com ele, tanto por uma interface de linha de comando quanto de forma programática com o Python. Esse fluxo de trabalho é ideal para prototipagem rápida e desenvolvimento local. Agora você tem uma base sólida para explorar opções de implantação mais avançadas.

5. Implantar o Gemma com o Ollama no Autopilot do GKE

Para cargas de trabalho de produção que exigem operações simplificadas e escalonabilidade, o Google Kubernetes Engine (GKE) é a plataforma de escolha. Nesta tarefa, você vai implantar o Gemma usando o Ollama em um cluster do Autopilot do GKE.

O Autopilot do GKE é um modo de operação no GKE em que o Google gerencia a configuração do cluster, incluindo nós, escalonamento, segurança e outras configurações predefinidas. Ele cria uma experiência do Kubernetes verdadeiramente "sem servidor", perfeita para executar cargas de trabalho de inferência sem gerenciar a infraestrutura de computação.

Preparar o ambiente do GKE

Para a tarefa final de implantação no Kubernetes, você vai provisionar um cluster do Autopilot do GKE.

  1. No terminal do Cloud Shell, defina as variáveis de ambiente para o projeto e a região desejada.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. Ative a API GKE para o projeto executando o seguinte no terminal:
    gcloud services enable container.googleapis.com
  3. Crie um cluster do Autopilot do GKE executando o seguinte no terminal: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Receba as credenciais do novo cluster executando o seguinte no terminal:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Implantar o Ollama e o Gemma

Agora que você tem um cluster do Autopilot do GKE, é possível implantar o servidor Ollama. O Autopilot vai provisionar automaticamente recursos de computação (CPU e memória) com base nos requisitos definidos no manifesto de implantação.

  1. Crie um arquivo chamado gemma-deployment.yaml executando o seguinte no terminal:
    cloudshell edit gemma-deployment.yaml
  2. Cole a seguinte configuração de YAML em gemma-deployment.yaml. Essa configuração define uma implantação que usa a imagem oficial do Ollama para execução na CPU.
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-gemma
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama-gemma
  template:
    metadata:
      labels:
        app: ollama-gemma
    spec:
      containers:
      - name: ollama-gemma-container
        image: ollama/ollama:0.12.10
        resources:
          requests:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
          limits:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
        # We use a script to start the server and pull the model
        command: ["/bin/bash", "-c"]
        args:
        - |
          ollama serve &
          OLLAMA_PID=$!
          echo "Waiting for Ollama server to start..."
          sleep 5
          echo "Pulling Gemma model..."
          ollama pull gemma3:1b
          echo "Model pulled. Ready to serve."
          wait $OLLAMA_PID
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0"
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: ollama-gemma
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 11434
    Confira uma explicação da configuração do Autopilot:
    • image: ollama/ollama:latest: especifica a imagem Docker oficial do Ollama.
    • resources: solicitamos explicitamente 8 vCPUs e 8Gi de memória. O Autopilot do GKE usa esses valores para provisionar a computação. Como não estamos usando GPUs, o modelo será executado na CPU. Os 8Gi de memória são suficientes para armazenar o modelo Gemma 1B e o contexto dele.
    • command/args: substituímos o comando de inicialização para garantir que o modelo seja extraído quando o pod for iniciado. O script inicia o servidor em segundo plano, aguarda a preparação, extrai o modelo gemma3:1b e mantém o servidor em execução.
    • OLLAMA_HOST: definir isso como 0.0.0.0 garante que o Ollama fique à escuta em todas as interfaces de rede no contêiner, tornando-o acessível ao serviço do Kubernetes.
  3. No terminal, aplique o manifesto de implantação ao cluster:
    kubectl apply -f gemma-deployment.yaml
    Leva alguns minutos para o Autopilot provisionar os recursos e para o pod ser iniciado. Você pode monitorar com:
    kubectl get pods --watch
    Aguarde até que o status do pod seja Running e READY seja 1/1 antes de continuar.

Testar o endpoint do GKE

O serviço do Ollama agora está em execução no cluster do Autopilot do GKE. Para testá-lo no terminal do Cloud Shell, você vai usar kubectl port-forward.

  1. Abra uma nova guia do terminal do Cloud Shell (clique no ícone + na janela do terminal). O comando port-forward é um processo de bloqueio, então ele precisa da própria sessão de terminal.
  2. No novo terminal, execute o comando a seguir para encaminhar uma porta local (por exemplo, 8000) para a porta do serviço (8000):
    kubectl port-forward service/llm-service 8000:8000
    Você vai receber uma saída indicando que o encaminhamento foi iniciado. Mantenha esse terminal em execução.
  3. Volte para o terminal original.
  4. Envie uma solicitação para a porta local 8000. O servidor Ollama expõe uma API compatível com o OpenAI e, devido ao encaminhamento de porta, agora é possível acessá-la em http://127.0.0.1:8000.
    curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gemma3:1b",
"messages": [
{"role": "user", "content": "Explain why the sky is blue."}
]
}'
    O serviço vai retornar uma resposta JSON com a conclusão do modelo.

6. Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste laboratório, siga estas etapas para excluir o cluster do GKE.

  1. No terminal do Cloud Shell, exclua o cluster do Autopilot do GKE:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Esse comando vai remover o cluster e todos os recursos associados.

7. Conclusão

Muito bem! Neste laboratório, você aprendeu vários métodos importantes para implantar modelos abertos no Google Cloud. Você começou com a simplicidade e a velocidade do desenvolvimento local com o Ollama. Por fim, você implantou o Gemma em um ambiente escalonável de nível de produção usando o Autopilot do Google Kubernetes Engine e o framework do Ollama.

Agora você tem o conhecimento necessário para implantar modelos abertos no Google Kubernetes Engine para cargas de trabalho exigentes e escalonáveis sem gerenciar a infraestrutura.

Recapitulação

Neste laboratório, você aprendeu:

Saiba mais