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 etapa do ciclo de vida de desenvolvimento.

O laboratório segue este caminho:

  • Prototipagem rápida: primeiro, execute um modelo com o Ollama localmente para ver como é fácil começar.
  • Implantação em 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 os modelos abertos

Hoje em dia, "modelo aberto" geralmente se refere a um modelo generativo de aprendizado de máquina disponível publicamente para download e uso por todos. Isso significa que a arquitetura do modelo e, mais importante, os parâmetros treinados ou "pesos" são divulgados 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 "por dentro" para entender o funcionamento interno do modelo.
  • Personalização: os usuários podem adaptar o modelo para tarefas específicas usando um processo chamado ajuste.
  • Inovação: permite que a comunidade crie aplicativos novos e inovadores com base em modelos avançados.

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

O Google contribui para o movimento de IA de código aberto há muitos anos. A arquitetura revolucionária do Transformer, apresentada no artigo de 2017 "Attention Is All You Need", é a base de quase todos os modelos de linguagem grandes modernos. Em seguida, vieram modelos abertos inovadores, como BERT, T5 e o Flan-T5 ajustado por instruções, cada um ampliando 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 nos modelos Gemini avançados 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, se integrem a um ecossistema diversificado e sigam uma estratégia de várias nuvens.

Destaque do Gemma 3

Neste laboratório, vamos focar no Gemma 3, a geração mais recente e avançada dessa família. Os modelos do 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.

  • Performance e tamanho: os modelos do 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. Elas oferecem qualidade superior e desempenho de ponta (SOTA, na sigla em inglês) para o tamanho delas.
  • Modalidade: eles são multimodais, capazes de processar entradas de texto e imagem para gerar saídas de texto.
  • Principais recursos: o Gemma 3 tem uma grande janela de contexto 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 treinar um modelo em um conjunto de dados massivo e diversificado para aprender padrões gerais de linguagem. Esses modelos são essencialmente máquinas de preenchimento automático avançadas.
  • O ajuste de instruções ajusta um modelo pré-treinado para seguir melhor instruções e comandos específicos. São os modelos que "sabem conversar".
  • Variantes de modelo: os modelos abertos geralmente 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, além de variantes, como pré-treinadas, quantizadas para eficiência ou ajustadas por instrução (-it).
  • Necessidades de recursos: os modelos de linguagem grande são grandes e exigem recursos de computação significativos para hospedagem. Embora possam ser executados localmente, a implantação 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 simples de modelos locais 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. Confira quando e por que escolher o GKE:

  • Gerenciamento simplificado com o Autopilot: o Autopilot do GKE gerencia a infraestrutura subjacente para você. Você se concentra na configuração do aplicativo, e o Autopilot provisiona e escalona os nós automaticamente.
  • Alta performance e escalonabilidade: lide com tráfego exigente e variável com o escalonamento automático do GKE. Isso garante que seu aplicativo possa oferecer alta capacidade com baixa latência, escalonando para cima ou para baixo conforme necessário.
  • Relação 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 das cargas de trabalho de inferência sem estado.
  • Portabilidade e ecossistema avançado: evite a dependência de fornecedores com uma implantação portátil baseada no Kubernetes. O GKE também oferece acesso ao vasto ecossistema nativo da nuvem (CNCF, na sigla em inglês) para as melhores ferramentas de monitoramento, geração de registros 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 escalonamento, desempenho e maturidade operacional sérios.

O que você vai aprender

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

  • Executar um modelo aberto localmente com o Ollama.
  • Implante um modelo aberto no Autopilot do Google Kubernetes Engine (GKE) com o Ollama para veiculação.
  • Entenda a progressão de frameworks de desenvolvimento local para uma arquitetura de serviç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.

Use uma conta pessoal em vez de uma conta escolar ou de 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 podem aproveitar a avaliação sem custos financeiros de US$300.

Criar um projeto (opcional)

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

3. Abrir editor do Cloud Shell

  1. Clique neste link para navegar diretamente até o editor do Cloud Shell.
  2. Se for preciso autorizar em algum 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 testar um modelo aberto.

O Ollama é uma ferramenta sem custo financeiro de código aberto 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 baixa e instala o Ollama e inicia o serviço dele.
  2. Inicie o serviço 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 prompt do Ollama no terminal, digite /bye e pressione ENTER.

Usar o SDK da OpenAI com o Ollama

Agora que o serviço Ollama está em execução, é possível interagir com ele de forma programática. Você vai usar o SDK do Python da OpenAI, 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 da OpenAI:
    uv pip install openai
  3. Crie um arquivo chamado ollama_chat.py inserindo no terminal:
    cloudshell edit ollama_chat.py
  4. Cole o seguinte código Python em ollama_chat.py. Esse código envia uma solicitação ao 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
    Depois de alguns segundos, você vai receber uma resposta semelhante à que recebeu da linha de comando.
  6. Para testar o modo de streaming, 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 eles são 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 streaming no terminal:
    python3 ollama_stream.py
    A resposta vai aparecer token por token.

O streaming é 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 toda a resposta seja gerada, o streaming 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: como executar modelos abertos com o Ollama

Você executou um modelo aberto usando o Ollama. Você viu como é simples baixar um modelo avançado como o Gemma 3 e interagir com ele, tanto por uma interface de linha de comando quanto de forma programática com 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 ideal. Nesta tarefa, você vai implantar o Gemma usando o Ollama em um cluster do GKE no modo Autopilot.

O GKE Autopilot é 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 pré-configuradas. 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 GKE no modo Autopilot.

  1. No terminal do Cloud Shell, defina 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 no projeto executando o seguinte no terminal:
    gcloud services enable container.googleapis.com
  3. Crie um cluster do GKE Autopilot 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 GKE Autopilot, é possível implantar o servidor Ollama. O Autopilot provisiona 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 ser executada 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 oficial do Docker do Ollama.
    • resources: solicitamos explicitamente 8 vCPUs e 8 GiB de memória. O GKE Autopilot usa esses valores para provisionar a computação subjacente. Como não estamos usando GPUs, o modelo será executado na CPU. Os 8 Gi 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 que ele fique pronto, extrai o modelo gemma3:1b e mantém o servidor em execução.
    • OLLAMA_HOST: definir como 0.0.0.0 garante que o Ollama fique disponível 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
    Levará 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 Ollama agora está sendo executado no cluster do Autopilot do GKE. Para testar no terminal do Cloud Shell, use 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 seguinte comando 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 ver uma saída indicando que o encaminhamento começou. Deixe esse terminal em execução.
  3. Volte ao terminal original.
  4. Envie uma solicitação para a porta local 8000. O servidor Ollama expõe uma API compatível com a OpenAI e, devido ao encaminhamento de porta, agora é possível acessá-lo 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 GKE Autopilot:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Esse comando remove 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 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 subjacente.

Recapitulação

Neste laboratório, você aprendeu a:

  • O que são modelos abertos e por que eles são importantes.
  • Como executar um modelo aberto localmente com o Ollama.
  • Como implantar um modelo aberto no Autopilot do Google Kubernetes Engine (GKE) usando o Ollama para inferência.

Saiba mais