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ó do 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 segurança em várias camadas, incluindo 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.
  • GKE Agent Sandbox: Esse recurso de segurança usa o gVisor, um ambiente de execução de contêiner de código aberto que fornece um kernel de 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 ser escalonada para o restante do cluster.
  • Protocolo de Contexto de Modelo (MCP) e ferramentas: esse protocolo estabelece uma maneira padrão para que os modelos de IA interajam 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ê poderá:

  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 sandboxes para minimizar o tempo gasto na inicialização de novos ambientes de execução.
  4. Aplicar limites de segurança:aplique políticas de rede para impedir 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 de 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.

Abrir o Cloud Shell

Para este 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), 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 (o ícone >_).
  3. Quando o terminal for aberto na parte de baixo do navegador, clique em Continuar , se solicitado.

Selecionar um projeto

É necessário garantir que o shell esteja 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 comando a seguir 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 código-fonte.
  • artifactregistry.googleapis.com::fornece um registro seguro e particular para as imagens do agente.
  • container.googleapis.com::gerencia o ciclo de vida do cluster do GKE e dos recursos de segurança.
  • aiplatform.googleapis.com::fornece acesso aos serviços da Vertex AI, incluindo modelos do Gemini para raciocínio e geração de código.

Criação do cluster

Este laboratório exige um cluster do GKE com o recurso do Agent Sandbox ativado. Usar o Autopilot do GKE é a maneira mais eficiente de começar, porque ele processa automaticamente o gerenciamento de nós, oferecendo suporte aos recursos de segurança necessários para a execução de código isolado.

👉💻 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 ao kubectl

Depois que o cluster for provisionado, será necessário configurar o kubectl para se comunicar com ele.

👉💻 O comando a seguir recupera as credenciais do cluster e atualiza o 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 o acesso do GKE à Vertex AI

Para permitir que o agente em execução no GKE acesse os serviços da Vertex AI para inferência de modelo, é necessário configurar a Identidade da carga de trabalho. Isso permite vincular uma conta de serviço do Kubernetes a um papel do Cloud IAM do Google Cloud, concedendo aos pods em execução como essa conta de serviço as permissões necessárias sem precisar gerenciar as chaves da 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 essa conta de serviço o papel de 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 ao papel 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 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 do agente

👉💻 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 do 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 do agente orientam a escrever e executar código baseado em pandas quando solicitado a analisar planilhas.

👉💻 Execute o comando a seguir para criar um arquivo chamado root_agent/agent.py com o seguinte 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 o seguinte conteúdo:

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

Em seguida, criamos um arquivo configurando variáveis de ambiente para o agente do ADK. GOOGLE_GENAI_USE_VERTEXAI=TRUE informa ao ADK para usar a Vertex AI para acessar 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 para chamadas de API da Vertex AI.

👉💻 Execute o comando a seguir para criar um arquivo chamado root_agent/.env com o seguinte 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

Contêinerizar o agente

Por fim, definimos a imagem do contêiner do agente. Ele começa com uma imagem de base do Python, instala o kubectl (necessário pelo cliente do sandbox do agente para se comunicar com o cluster) e instala 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 o seguinte 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, é necessário 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 Agent Sandbox

É possível implantar o controlador do Agent Sandbox e os componentes necessários aplicando 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 Agent Sandbox no cluster.

👉💻 Execute os comandos a seguir para implantar o controlador do Agent Sandbox 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 e o pool quente do sandbox

Agora, defina a configuração do sandbox criando um SandboxTemplate e um recurso SandboxWarmPool. O SandboxTemplate atua como um blueprint reutilizável que o controlador do Agent Sandbox 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 normal.

👉💻 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 do sandbox

O cliente Python que você vai usar para criar e interagir com ambientes de 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, é necessário aplicar uma política de rede. Essa política garante que os pods do sandbox não possam alcançar 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, crie 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 de controle de acesso baseado em papéis (RBAC, na sigla em inglês) necessárias (Role e RoleBinding) para conceder ao agente permissão para interagir com o controlador do Agent Sandbox 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://[EXTERNAL_IP] no navegador da Web, substituindo [EXTERNAL_IP] pelo endereço recebido 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 de varejo recomendado para 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ó do 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 orientados por IA no GKE. Ao combinar o Kit de Desenvolvimento de Agente (ADK) para raciocínio com o GKE Agent Sandbox 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 fornece isolamento no nível do kernel, as políticas de rede impedem o movimento lateral e os pools quentes garantem que essas camadas de segurança não degradem a performance do aplicativo. Essa arquitetura representa o padrão para a 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.

Revisão dos dados

👉💻 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 para leitura adicional: