Como implantar agentes de IA seguros no GKE

1. Introdução

Este laboratório se concentra no desenvolvimento e na segurança de agentes de IA que executam código dinâmico em um ambiente de produção. À medida que os aplicativos de IA vão além das interfaces de chat simples, eles geralmente exigem a capacidade de realizar lógicas complexas, como análise de dados, modelagem matemática ou processamento de arquivos, gerando e executando código em tempo real. Este laboratório demonstra como usar o Kit de Desenvolvimento de Agente (ADK) para criar agentes de raciocínio e o GKE Agent Sandbox para garantir que qualquer código gerado pela IA seja executado em um ambiente altamente isolado e seguro.

O desafio técnico do código não confiável

Quando um agente de IA gera e executa código (como Python), ele essencialmente executa uma carga de trabalho não confiável na sua infraestrutura. Se o agente for comprometido ou instruído a realizar ações maliciosas, ele poderá tentar acessar variáveis de ambiente sensíveis, verificar sua rede interna ou explorar o nó host subjacente. O isolamento de contêineres tradicional geralmente é insuficiente para essas cargas de trabalho dinâmicas. Para resolver isso, os engenheiros de plataforma precisam implementar uma segurança em várias camadas que inclua isolamento no nível do kernel e saída de rede restrita.

Conceitos básicos

  • Kit de Desenvolvimento de Agente (ADK): o ADK é um framework usado para criar aplicativos que podem raciocinar sobre tarefas. Ele gerencia um "raciocínio de repetição" em que a IA recebe um comando, planeja uma série de ações, chama ferramentas específicas e resume a saída final. Nesse fluxo de trabalho, o ADK atua como o orquestrador que identifica quando uma solicitação do usuário exige a execução de código.
  • Sandbox do agente do GKE:esse recurso de segurança usa o gVisor (em inglês), um ambiente de execução de contêiner de código aberto que fornece um kernel convidado especializado para cada contêiner. Ao interceptar chamadas de sistema (syscalls) entre o aplicativo e o kernel do host, o GKE Agent Sandbox impede que códigos não confiáveis interajam diretamente com o nó. Isso garante que uma violação de segurança no contêiner não possa se estender ao restante do cluster.
  • Protocolo de Contexto de Modelo (MCP) e ferramentas:esse protocolo estabelece uma maneira padrão para os modelos de IA interagirem com ferramentas externas. Neste laboratório, o agente é configurado com uma ferramenta de "Execução de código" que se comunica com um controlador de sandbox especializado para executar scripts Python.

Objetivos do laboratório

Ao final desta sessão, você vai saber:

  1. Desenvolver um agente:configure um agente baseado no ADK projetado para tarefas de análise de dados.
  2. Configurar o isolamento do kernel:configure o GKE Agent Sandbox com RuntimeClasses especializados.
  3. Otimizar a performance:implemente um "pool quente" de sandbox para minimizar o tempo gasto na inicialização de novos ambientes de execução.
  4. Aplicar limites de segurança:use políticas de rede para evitar a saída não autorizada do ambiente de execução.

2. Configuração do projeto

Um ambiente configurado corretamente é essencial antes de começar a criar aplicativos com agentes. Nesta seção, você vai acessar as ferramentas necessárias e garantir que seu projeto na nuvem do Google Cloud esteja pronto para hospedar o agente de IA e o ambiente de execução seguro dele.

Abrir o Cloud Shell

Neste laboratório, vamos usar o Cloud Shell, um ambiente de terminal baseado em navegador fornecido pelo Google Cloud. O Cloud Shell vem pré-configurado com a CLI do Google Cloud (gcloud), o kubectl e o ambiente Docker necessário para criar e implantar seu aplicativo.

  1. Acesse o Console do Google Cloud.
  2. Clique no botão Ativar o Cloud Shell no cabeçalho superior direito (ícone >_).
  3. Quando o terminal abrir na parte de baixo do navegador, clique em Continuar se solicitado.

Selecionar um projeto

Verifique se o shell está apontando para o projeto na nuvem correto do Google Cloud para evitar a implantação de recursos no ambiente errado.

👉💻 Identifique o ID do projeto no painel do console e execute o seguinte comando para definir o projeto no shell atual:

gcloud config set project [YOUR_PROJECT_ID]

Ativar APIs

A criação e a implantação de agentes exigem várias APIs especializadas para builds de contêineres, hospedagem de imagens e acesso a modelos generativos.

👉💻 Execute o comando a seguir para inicializar esses serviços:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com::automatiza a criação de imagens de contêiner com base no seu código-fonte.
  • artifactregistry.googleapis.com::fornece um registro seguro e particular para as imagens do seu agente.
  • container.googleapis.com::gerencia o ciclo de vida do cluster do GKE e os recursos de segurança dele.
  • aiplatform.googleapis.com::oferece acesso aos serviços da Vertex AI, incluindo modelos do Gemini para raciocínio e geração de código.

Criação de cluster

Este laboratório exige um cluster do GKE com o recurso Agent Sandbox ativado. Usar o GKE Autopilot é a maneira mais eficiente de começar, já que ele gerencia automaticamente os nós e oferece suporte aos recursos de segurança necessários para a execução isolada de código.

👉💻 Execute os comandos a seguir para criar o cluster do GKE:

export PROJECT_ID=$(gcloud config get-value project)

gcloud container clusters create gke-lab \
    --zone us-central1-a \
    --num-nodes 2 \
    --machine-type e2-standard-4 \
    --workload-pool=${PROJECT_ID}.svc.id.goog

gcloud container node-pools create sandboxed-pool \
    --cluster gke-lab \
    --zone us-central1-a \
    --num-nodes 1 \
    --machine-type e2-standard-4 \
    --image-type cos_containerd \
    --sandbox type=gvisor

Observação: o provisionamento de um novo cluster geralmente leva de 8 a 10 minutos. Você pode ativar as APIs em uma nova guia ou enquanto o comando é processado.

Configurar o acesso do kubectl

Depois que o cluster for provisionado, você precisará configurar kubectl para se comunicar com ele.

👉💻 O comando a seguir recupera as credenciais do cluster e atualiza seu arquivo kubeconfig local, permitindo que você execute comandos no novo cluster do GKE no Cloud Shell:

gcloud container clusters get-credentials gke-lab --zone us-central1-a

Com isso, os comandos kubectl agora vão segmentar o cluster gke-lab por padrão.

Permitir que o GKE acesse a Vertex AI

Para permitir que o agente em execução no GKE acesse os serviços da Vertex AI para inferência de modelo, configure a Identidade da carga de trabalho. Isso permite vincular uma conta de serviço do Kubernetes a uma função do Cloud IAM do Google Cloud, concedendo aos pods executados como essa conta de serviço as permissões necessárias sem precisar gerenciar chaves de conta de serviço.

👉💻 Primeiro, crie a conta de serviço do Kubernetes que os pods do agente vão usar:

kubectl create serviceaccount adk-agent-sa

Em seguida, conceda a esta conta de serviço o papel Vertex AI User adicionando uma vinculação de política do IAM.

👉💻 Esse comando vincula a conta de serviço do Kubernetes adk-agent-sa no namespace default à função do IAM roles/aiplatform.user para o pool de Identidade da carga de trabalho do seu projeto.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

gcloud projects add-iam-policy-binding projects/${PROJECT_ID} \
    --role=roles/aiplatform.user \
    --member=principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/adk-agent-sa \
    --condition=None

3. Como criar o agente do ADK

Nesta seção, você vai definir a lógica do seu agente. O agente atua como um especialista em dados que pode escrever código Python para processar arquivos. Essa lógica de raciocínio permite que o agente reconheça quando uma solicitação de linguagem natural de um usuário exige um cálculo matemático ou baseado em dados que é melhor processado por código.

Criar o diretório de agentes

👉💻 Crie um diretório para o laboratório e um subdiretório para o código-fonte do agente:

mkdir -p ~/gke-sandbox-lab/root_agent
cd ~/gke-sandbox-lab

Definir o agente do ADK

Primeiro, definimos a lógica principal do agente. Nosso agente usa o framework ADK para definir um agente chamado SpreadsheetAnalyst que usa o modelo gemini-2.5-flash. Ele inclui uma ferramenta (run_spreadsheet_analysis) que chama o GKE Agent Sandbox para executar código Python com segurança. As instruções orientam o agente a escrever e executar códigos baseados em pandas quando solicitado a analisar planilhas.

👉💻 Execute o comando a seguir para criar um arquivo chamado root_agent/agent.py com este conteúdo:

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/agent.py
import pandas as pd
from google.adk.agents import Agent
from k8s_agent_sandbox import SandboxClient

# Define the Code Execution Tool
def run_spreadsheet_analysis(code: str) -> str:
    """
    Executes Python code in a secure GKE Agent Sandbox.
    Use this tool to run pandas-based analysis on spreadsheet data.
    Input should be a complete Python script.
    """
    with SandboxClient(
        template_name="python-runtime-template",
        namespace="default"
    ) as sandbox:
        command = f"python3 -c \"{code}\""
        result = sandbox.run(command)
        
        if result.stderr:
            return f"Error: {result.stderr}"
        return result.stdout

# Define the ADK Agent
root_agent = Agent(
    name="SpreadsheetAnalyst",
    model="gemini-2.5-flash",
    instruction="""
    You are an expert data analyst. When a user asks to analyze a spreadsheet:
    1. Reason about what Python code (using pandas) is needed.
    2. Write the code, ensuring it handles data loading and analysis.
    3. Do not ever use double-quotes for string, always use single-quotes.
    4. Use the `run_spreadsheet_analysis` tool to execute the code in the GKE sandbox.
    5. Provide a clear summary of the analysis based on the tool's output.
    
    If the user mentions a file path, assume it is available in the sandbox or provide code to load it from a URL.
    """,
    tools=[run_spreadsheet_analysis]
)
EOF

Para permitir que o ADK descubra e carregue a definição do agente de agent.py e saiba sobre nosso agente, garantimos que root_agent seja visto como um pacote Python.

👉💻 Execute o comando a seguir para criar um arquivo vazio chamado root_agent/__init__.py com este conteúdo:

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/__init__.py
from . import agent
EOF

Em seguida, criamos um arquivo que configura variáveis de ambiente para o agente do ADK. GOOGLE_GENAI_USE_VERTEXAI=TRUE informa ao ADK para usar a Vertex AI no acesso aos modelos do Gemini, e GOOGLE_CLOUD_PROJECT e GOOGLE_CLOUD_LOCATION especificam o projeto na nuvem e a região do Google Cloud a serem usados nas chamadas de API da Vertex AI.

👉💻 Execute o comando a seguir para criar um arquivo chamado root_agent/.env com este conteúdo:

cat <<EOF > ~/gke-sandbox-lab/root_agent/.env
GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT=$PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
EOF

Colocar o agente em um contêiner

Por fim, definimos a imagem do contêiner para o agente. Ele começa com uma imagem base do Python, instala o kubectl (necessário para que o cliente da sandbox do agente se comunique com o cluster) e as bibliotecas Python necessárias: google-adk, pandas e agentic-sandbox-client do repositório git. Por fim, ele copia o código-fonte do agente para a imagem e define o ponto de entrada para executar o servidor da Web do ADK, que expõe a interface e a API do agente.

👉💻 Execute o comando a seguir para criar um arquivo chamado Dockerfile com este conteúdo:

cat <<'EOF' > ~/gke-sandbox-lab/Dockerfile
FROM python:3.14-slim

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

RUN apt-get update && apt-get install -y \
    git \
    curl \
    && curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" \
    && install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl \
    && rm kubectl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

RUN pip install --no-cache-dir google-adk pandas "git+https://github.com/kubernetes-sigs/agent-sandbox.git@main#subdirectory=clients/python/agentic-sandbox-client"

COPY ./root_agent /app/root_agent

WORKDIR /app

EXPOSE 8080

ENTRYPOINT ["adk", "web", "--host", "0.0.0.0", "--port", "8080"]
EOF

Criar a imagem do agente

O agente precisa ser empacotado como uma imagem do contêiner. Vamos usar o Cloud Build para empacotar o agente e armazená-lo no Artifact Registry.

👉💻 Execute o comando a seguir para criar o repositório:

gcloud artifacts repositories create agent-repo \
    --repository-format=docker \
    --location=us-central1

👉💻 Execute o comando a seguir para criar a imagem:

gcloud builds submit --tag us-central1-docker.pkg.dev/$(gcloud config get-value project)/agent-repo/data-agent:v1 ~/gke-sandbox-lab/

4. Implementar a infraestrutura do sandbox

Agora que a lógica do agente está definida, é preciso configurar a infraestrutura que permite a execução segura de código não confiável. Isso envolve a configuração do ambiente de execução de isolamento e dos controles de rede.

Implantar o controlador do sandbox do agente

Para implantar o controlador do Sandbox do agente e os componentes necessários, aplique os manifestos de lançamento oficiais ao cluster. Esses manifestos são arquivos de configuração que instruem o Kubernetes a fazer o download de todos os componentes necessários para implantar e executar o controlador do sandbox do agente no cluster.

👉💻 Execute os comandos a seguir para implantar o controlador do ambiente de simulação do agente no cluster do GKE:

kubectl apply \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/manifest.yaml \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/extensions.yaml

Criar o modelo de sandbox e o pool quente de sandbox

Agora, defina a configuração da sua sandbox criando um SandboxTemplate e um recurso SandboxWarmPool. O SandboxTemplate funciona como um blueprint reutilizável que o controlador do sandbox do agente usa para criar ambientes de sandbox consistentes e pré-configurados. O recurso SandboxWarmPool garante que um número especificado de pods pré-aquecidos esteja sempre em execução e pronto para ser reivindicado. Um sandbox pré-aquecido é um pod em execução que já foi inicializado. Essa pré-inicialização permite que novos sandboxes sejam criados em menos de um segundo e evita a latência de inicialização de um sandbox comum.

👉💻 Execute o comando a seguir para criar um arquivo chamado sandbox-template-and-pool.yaml:

cat <<EOF > ~/gke-sandbox-lab/sandbox-template-and-pool.yaml
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: python-runtime-template
  namespace: default
spec:
  podTemplate:
    metadata:
      labels:
        sandbox: python-sandbox-example
    spec:
      runtimeClassName: gvisor
      containers:
      - name: python-runtime
        image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
        ports:
        - containerPort: 8888
        readinessProbe:
          httpGet:
            path: "/"
            port: 8888
          initialDelaySeconds: 0
          periodSeconds: 1
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
            ephemeral-storage: "512Mi"
      restartPolicy: "OnFailure"
---
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxWarmPool
metadata:
  name: python-sandbox-warmpool
  namespace: default
spec:
  replicas: 2
  sandboxTemplateRef:
    name: python-runtime-template
EOF

👉💻 Aplique a configuração:

kubectl apply -f ~/gke-sandbox-lab/sandbox-template-and-pool.yaml

Criar o roteador de sandbox

O cliente Python que você vai usar para criar e interagir com ambientes em sandbox usa um componente chamado roteador de sandbox para se comunicar com os sandboxes.

👉💻 Execute o comando a seguir para criar um arquivo chamado sandbox-router.yaml:

cat <<EOF > ~/gke-sandbox-lab/sandbox-router.yaml
apiVersion: v1
kind: Service
metadata:
  name: sandbox-router-svc
  namespace: default
spec:
  type: ClusterIP
  selector:
    app: sandbox-router
  ports:
  - name: http
    protocol: TCP
    port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sandbox-router-deployment
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sandbox-router
  template:
    metadata:
      labels:
        app: sandbox-router
    spec:
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: topology.kubernetes.io/zone
          whenUnsatisfiable: ScheduleAnyway
          labelSelector:
            matchLabels:
              app: sandbox-router
      containers:
      - name: router
        image: us-central1-docker.pkg.dev/k8s-staging-images/agent-sandbox/sandbox-router:v20260225-v0.1.1.post3-10-ga5bcb57
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
EOF

👉💻 Aplique a configuração:

kubectl apply -f ~/gke-sandbox-lab/sandbox-router.yaml

Implementar o isolamento de rede

Para impedir que o código gerado acesse dados sensíveis, aplique uma política de rede. Essa política garante que os pods de sandbox não possam acessar o servidor de metadados do Google Cloud ou outros IPs internos.

👉💻 Execute o comando a seguir para criar um arquivo chamado sandbox-policy.yaml:

cat <<EOF > ~/gke-sandbox-lab/sandbox-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-sandbox-egress
spec:
  podSelector:
    matchLabels:
      sandbox: python-sandbox
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32 # Block metadata server
EOF

👉💻 Aplique a política:

kubectl apply -f ~/gke-sandbox-lab/sandbox-policy.yaml

5. Implantação e verificação

Com o agente e a infraestrutura de segurança configurados, agora você vai implantar os componentes e verificar se os limites de segurança funcionam conforme o esperado.

Implantar o agente

Agora você vai criar o manifesto do Kubernetes para implantar o agente do ADK. Esse manifesto inclui vários componentes principais: um Deployment para gerenciar o contêiner do agente, um Service do tipo LoadBalancer para expor a interface e o endpoint de API do agente ao tráfego externo e as regras necessárias de controle de acesso baseado em função (RBAC, na sigla em inglês) (Role e RoleBinding) para conceder ao agente permissão para interagir com o controlador do ambiente de simulação do agente e gerenciar instâncias de sandbox.

👉💻 Execute o comando a seguir para criar um arquivo chamado deployment.yaml:

cat <<EOF > ~/gke-sandbox-lab/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: data-agent
  labels:
    app: data-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: data-agent
  template:
    metadata:
      labels:
        app: data-agent
    spec:
      serviceAccount: adk-agent-sa
      containers:
      - name: data-agent
        image: us-central1-docker.pkg.dev/$PROJECT_ID/agent-repo/data-agent:v1
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: data-agent-service
spec:
  selector:
    app: data-agent
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: sandbox-creator-role
rules:
# 1. Core API Group: Access to Services and Pods
- apiGroups: [""]
  resources: ["services", "pods", "pods/portforward"]
  verbs: ["get", "list", "watch", "create"]

# 2. Rules for Sandbox Claims
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxclaims"]
  verbs: ["create", "get", "list", "watch", "delete"]

# 3. Rules for the actual Sandboxes
- apiGroups: ["agents.x-k8s.io"]
  resources: ["sandboxes"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: adk-agent-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: adk-agent-sa
  namespace: default
roleRef:
  kind: Role
  name: sandbox-creator-role
  apiGroup: rbac.authorization.k8s.io
EOF

👉💻 Aplique a configuração:

kubectl apply -f ~/gke-sandbox-lab/deployment.yaml

Abrir a interface da Web do ADK

Depois que a implantação for concluída, você poderá verificar o status dela.

👉💻 Verifique se os pods do agente estão em execução:

kubectl get pods

👉💻 Recupere o IP externo e encontre o endereço IP externo atribuído ao serviço do agente:

kubectl get services

Procure o valor EXTERNAL-IP associado ao data-agent-service.

Abra a interface da Web do ADK navegando até http:// no navegador da Web e substituindo pelo endereço obtido na etapa anterior.

Verificar tarefas legítimas

Teste o agente com uma solicitação de dados padrão para garantir que a comunicação entre o agente, o controlador e o sandbox esteja funcionando.

  • 👉💬 Comando:
Here is some inventory data in CSV format. Can you calculate the total value of all items in inventory?
product,quantity,msrp
Laptop,10,1200
Keyboard,50,75
Mouse,75,25
Monitor,20,300
Webcam,40,50
  • Observação:o agente gera código Python para analisar os dados CSV, multiplica a quantidade pelo preço sugerido de cada produto, soma o valor total e retorna o resultado.

Verificar limites de segurança

Teste a eficácia do GKE Agent Sandbox tentando realizar operações restritas.

  1. Teste de isolamento do sistema:
    • 👉💬 Comando : Write a Python script to list the contents of /etc/shadow on the host.
    • Resultado:o script vai falhar ou retornar um sistema de arquivos virtualizado e restrito. O gVisor impede que o contêiner veja os arquivos sensíveis do nó host.
  2. Teste de isolamento de rede:
    • 👉💬 Comando : Try to fetch the project ID from http://metadata.google.internal.
    • Resultado:a solicitação será bloqueada pela política de rede, confirmando que o código não pode acessar as credenciais para envolvidos no projeto.

6. Conclusão

Este laboratório demonstrou uma abordagem abrangente para proteger aplicativos baseados em IA no GKE. Ao combinar o Kit de Desenvolvimento de Agente (ADK) para raciocínio com o Sandbox de Agente do GKE para execução, você criou um sistema que oferece suporte a código dinâmico gerado por IA sem expor a infraestrutura subjacente a riscos.

O uso do gVisor oferece isolamento no nível do kernel, as políticas de rede evitam o movimento lateral, e os pools quentes garantem que essas camadas de segurança não prejudiquem o desempenho do aplicativo. Essa arquitetura representa o padrão para implantação de agentes de raciocínio que exigem ambientes de execução de código seguros.

Resumo do laboratório

  • Desenvolvimento de agentes:você configurou um agente baseado no ADK que planeja e executa ferramentas com base na intenção do usuário.
  • Isolamento seguro:você usou o gVisor para fornecer separação no nível do kernel para execução de código não confiável.
  • Controle de saída:você implementou políticas de rede para isolar o ambiente de execução de serviços de nuvem sensíveis.
  • Performance:você usou pools quentes para fornecer tempos de inicialização quase instantâneos para contêineres isolados.

Limpeza

👉💻 Para evitar cobranças contínuas, exclua os recursos criados durante este laboratório.

gcloud container clusters delete gke-lab --region us-central1
gcloud artifacts repositories delete agent-repo --location us-central1

Próximas etapas

Recomendações de leitura complementar: