Como começar a usar os servidores MCP do Google

1. Introdução

Olá! Neste codelab, você vai aprender a turbinar seus agentes de IA usando os servidores do Protocolo de Contexto de Modelo (MCP) gerenciados pelo Google.

O Protocolo de Contexto de Modelo (MCP) é um padrão de código aberto que permite que modelos de IA se conectem com segurança e eficiência a fontes de dados e ferramentas externas. Embora a maioria das implementações do MCP seja executada localmente na sua máquina, o Google oferece servidores MCP remotos gerenciados. São endpoints totalmente hospedados e prontos para empresas que permitem que seus agentes interajam diretamente com a infraestrutura em nuvem do Google Cloud sem que você precise gerenciar contêineres ou código do lado do servidor.

A vantagem de ser "gerenciado"

Ao contrário dos servidores MCP locais que usam entrada/saída padrão (stdio), os servidores gerenciados do Google utilizam HTTP transmissível. Essa arquitetura oferece:

  • Infraestrutura zero:não há servidores para provisionar ou escalonar.
  • Segurança por design:integração nativa com o Cloud IAM e os Registros de auditoria do Google Cloud.
  • Escalonamento sem estado:interação perfeita por balanceadores de carga e proxies padrão.

O que você vai aprender

  • Como ativar e autenticar servidores MCP gerenciados.
  • Como usar o servidor MCP do Cloud Logging como uma base fundamental.
  • Como orquestrar vários servidores MCP (conhecimento do desenvolvedor, Firestore etc.) para criar fluxos de trabalho autônomos.

O que é necessário

  • Ter um projeto do Google Cloud com o faturamento ativado.
  • Familiaridade com o console do Google Cloud e a CLI gcloud.
  • Google Cloud Shell (a CLI do Gemini já está pré-instalada aqui).

Este codelab foi criado para usuários e desenvolvedores de todos os níveis, inclusive iniciantes.

Problemas nos relatórios

Ao trabalhar no codelab e com o Antigravity, você pode encontrar problemas.

Para problemas relacionados ao codelab (erros de digitação, instruções incorretas), abra um bug com o botão Report a mistake no canto inferior esquerdo deste codelab:

b06b582bcd847f6d.png

2. Antes de começar

Nesta etapa, você vai preparar seu ambiente do Google Cloud. Vamos realizar todas as tarefas no Google Cloud Shell, que oferece um terminal persistente e pré-configurado.

Ativar o Cloud Shell

  1. Navegue até o Console do Google Cloud.
  2. Clique no ícone Ativar o Cloud Shell no cabeçalho da parte superior direita.
  3. Quando a sessão do terminal começar, autorize o comando se solicitado.

Definir o ID do projeto

Verifique se o Cloud Shell está apontando para o projeto correto:

# Set your active project
gcloud config set project YOUR_PROJECT_ID

# Verify the setting
gcloud config list project

Ativar APIs Foundation

Os servidores MCP gerenciados exigem que a API do produto e a interface MCP estejam ativadas. Execute o comando a seguir para ativar o back-end do Cloud Logging (nossa referência para este laboratório):

# Enable the Cloud Logging API and its MCP interface
gcloud services enable logging.googleapis.com
gcloud beta services mcp enable logging.googleapis.com

Observação:no momento, os serviços gerenciados do MCP estão na versão Beta. É necessário usar o componente gcloud beta para ativá-las.

Configurar o Application Default Credentials (ADC)

A CLI do Gemini usa sua identidade de usuário para se comunicar com servidores MCP. Conceda permissão ao agente para agir em seu nome:

gcloud auth application-default login

Siga o URL no terminal, faça login e cole o código de autorização de volta no Cloud Shell.

Atribuir papéis básicos do IAM

Os servidores MCP gerenciados usam um modelo de segurança de duas camadas. Você precisa que dois "portões" específicos estejam abertos:

  1. Gate 1 (acesso ao MCP): a função que permite chamar o protocolo.
  2. Etapa 2 (acesso ao serviço): a função que permite ver os dados (por exemplo, visualizar registros).

Execute o seguinte para conceder a si mesmo o acesso necessário:

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

# Gate 1: Permission to use the MCP protocol
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/mcp.toolUser"

# Gate 2: Permission to view the actual logs
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/logging.viewer"

3. Fundamentos: como conectar seu primeiro servidor MCP

Nesta etapa, você vai vincular seu agente de IA (CLI do Gemini) ao servidor MCP do Google Cloud Logging. Essa é nossa "base" porque permite que o agente veja o que está acontecendo dentro do seu projeto em tempo real.

Tarefa 1: configurar o servidor MCP do Logging

A CLI do Gemini usa um arquivo settings.json para gerenciar as conexões. Edite esse arquivo (presente na pasta ~/.gemini) para adicionar o seguinte snippet dentro do bloco mcpServers. Substitua YOUR_PROJECT_ID pelo ID do projeto:

"logging-mcp": {
      "httpUrl": "https://logging.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/logging.read"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
}

Observação: o cabeçalho x-goog-user-project é necessário para que os servidores do MCP gerenciado garantam que o uso da API e o faturamento sejam atribuídos corretamente ao seu projeto.

Tarefa 2: simular a atividade do projeto (criar registros)

Se o projeto for novo ou estiver inativo, talvez ele não tenha registros "interessantes" recentes. Vamos usar a CLI gcloud para injetar algumas entradas personalizadas para que o agente tenha algo para encontrar.

Execute estes comandos um por um para simular uma sequência de eventos:

# 1. Simulate a standard system start
gcloud logging write mcp-test-log "System boot sequence initiated" --severity=INFO
# 2. Simulate a warning about resource limits
gcloud logging write mcp-test-log "High memory pressure detected in zone us-central1-a" --severity=WARNING
# 3. Simulate a critical authentication failure
gcloud logging write mcp-test-log "ERROR: Failed to connect to Cloud SQL. Permission Denied." --severity=ERROR

Tarefa 3: verificar as ferramentas na CLI do Gemini

Antes de começarmos a conversar, vamos verificar se o agente consegue "ver" as ferramentas expostas pelo servidor do Logging. Inicie a CLI do Gemini:

gemini

Na solicitação da CLI do Gemini (>), execute o comando list:

/mcp list

Ponto de verificação:o logging-mcp vai aparecer como Pronto com aproximadamente seis ferramentas disponíveis, incluindo o list_log_entries.

Tarefa 4: seu primeiro comando de infraestrutura ativa

Agora, vamos pedir ao agente para encontrar os registros que acabamos de criar. Como você concedeu o papel roles/logging.viewer antes, o agente agora pode "entrar em contato" e ler o estado do projeto.

Digite o seguinte comando na CLI do Gemini:

Show me the 3 most recent log entries from the log named 'mcp-test-log'. What is the highest severity issue you see?

Observe o agente:

  1. O agente pode pedir o ID do projeto do Google Cloud. Informe isso.
  2. Ele vai identificar que precisa da ferramenta list_log_entries.
  3. Ele vai pedir sua permissão para executar a ferramenta. Selecione 1. Sim, permitir uma vez.
  4. Ele vai analisar a resposta JSON e informar sobre o erro Permissão negada do Cloud SQL que simulamos.

4. Jornada A: O cérebro (MCP de conhecimento do desenvolvedor)

Nesta jornada, você vai dar um "cérebro" ao seu agente conectando-o ao servidor MCP do Google Developer Knowledge.

Um dos maiores riscos com agentes de IA é a alucinação, ou seja, fornecer comandos da CLI desatualizados ou parâmetros de API descontinuados com confiança. O servidor MCP resolve isso ao fundamentar o agente no corpus oficial e ativo da documentação para desenvolvedores do Google, que abrange o Google Cloud, o Firebase, o Android e muito mais.

Tarefa 1: ativar os Serviços de conhecimento

Assim como na etapa de base, precisamos ativar a API de back-end e o endpoint de serviço do MCP.

# 1. Enable the Developer Knowledge API
gcloud services enable developerknowledge.googleapis.com

# 2. Enable the MCP Server interface
gcloud beta services mcp enable developerknowledge.googleapis.com

Tarefa 2: provisionar uma chave de API restrita

O MCP de conhecimento do desenvolvedor usa chaves de API para autenticação. Por segurança, vamos criar uma chave e restringi-la para que ela possa ser usada apenas com essa API específica.

  1. Execute o script a seguir para criar e recuperar sua chave:
# Create the restricted API key
gcloud alpha services api-keys create \
    --display-name="MCP-Knowledge-Key" \
    --api-target service=developerknowledge.googleapis.com

# Wait a few seconds for the key to propagate, then fetch the string
gcloud alpha services api-keys get-key-string \
    $(gcloud alpha services api-keys list \
    --filter="displayName='MCP-Knowledge-Key'" \
    --format="value(name)") \
    --format="value(keyString)"
  1. Copie a string longa de caracteres retornada pelo segundo comando. Este é seu YOUR_API_KEY.

Tarefa 3: configurar a CLI do Gemini

Agora, registre o servidor MCP de conhecimento com seu agente. Isso permite que o agente pesquise a documentação oficial sempre que encontrar uma pergunta técnica que não pode responder com 100% de certeza.

Adicione o snippet a seguir na seção "mcpServers" do arquivo ~/.gemini/settings.json, substituindo YOUR_API_KEY pela string que você acabou de copiar:

"developer-knowledge-mcp": {
      "httpUrl": "https://developerknowledge.googleapis.com/mcp",
      "headers": {
        "X-Goog-Api-Key": "YOUR_API_KEY"
      }
}

Tarefa 4: o teste de anti-alucinação

Vamos verificar se o agente agora está "pesquisando" em vez de "adivinhando".

Inicie a CLI do Gemini:

gemini

Verifique se o servidor está pronto: digite /mcp list. Você vai encontrar google-developer-knowledge com duas ferramentas (search_documents, get_document).

O comando:peça ao agente para encontrar um comando específico e moderno.

I want to create a Google Cloud Storage bucket using the modern gcloud storage command. Search the official documentation for the exact syntax and show me an example for a bucket in the 'us-central1' region.

O que procurar:

  • O Gemini vai pedir permissão para usar search_documents.
  • Em seguida, ele provavelmente vai chamar get_document para ler a página específica encontrada.
  • A resposta final precisa incluir um comando gcloud storage buckets create ..., citado diretamente da documentação.

5. Jornada B: a triagem (solução de problemas autônoma)

Pré-requisito:para fazer esta jornada, você precisa ter concluído a Jornada A: O cérebro para que o agente possa pesquisar correções.

Nesta jornada, você vai combinar os Olhos (MCP do Cloud Logging) e o Cérebro (MCP do Developer Knowledge) do seu agente para criar um Loop de solução de problemas autônomo.

Em vez de copiar manualmente códigos de erro em um mecanismo de pesquisa, você vai dar ao agente um único comando para verificar erros no seu projeto, pesquisar a resolução oficial e gerar um relatório de correção útil.

Tarefa 1: simular um "dia ruim" no GCP

Para ver o poder da solução de problemas autônoma, precisamos de um conjunto realista de falhas. Vamos usar um script Python para injetar vários obstáculos de infraestrutura, desde erros de permissão negada até problemas de cota, diretamente nos seus registros.

  1. No Cloud Shell, crie uma pasta de sua escolha e navegue até ela.
  2. crie um arquivo chamado simulate_errors.py:
nano simulate_errors.py
  1. Cole o seguinte código no editor:
import argparse
from google.cloud import logging

def simulate_errors(project_id):
    client = logging.Client(project=project_id)
    logger = client.logger("mcp-scenario-logger")

    print(f"Simulating realistic errors for project: {project_id}...")

    # 1. GCS Permission Error
    logger.log_text("ERROR: GCS Upload failed for 'gs://my-app-bucket/data.json'. Status: 403 Forbidden. Missing 'storage.objects.create' for service account.", severity="ERROR")

    # 2. Cloud Run Startup Error
    logger.log_text("ERROR: Cloud Run service 'api-gateway' failed to start. Container failed to listen on port 8080. Check 'Cloud Run container startup requirements'.", severity="ERROR")

    # 3. Secret Manager Access Error
    logger.log_text("ERROR: Access denied to secret 'API_KEY'. The identity lacks 'secretmanager.versions.access'.", severity="ERROR")

    print("Log entries written to 'mcp-scenario-logger'.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--project", required=True)
    args = parser.parse_args()
    simulate_errors(args.project)
  1. Pressione Ctrl+O, Enter e Ctrl+X para salvar e sair.
  2. Instale a biblioteca Google Cloud Logging e execute o script:
python -m venv mcp_env
source mcp_env/bin/activate
pip install google-cloud-logging
python simulate_errors.py --project $(gcloud config get-value project)

Tarefa 2: executar o loop autônomo

Agora, vamos enviar um comando complexo que instrui o Gemini a orquestrar os dois servidores MCP simultaneamente.

Inicie a CLI do Gemini:

gemini

Digite este "comando principal" no agente:

I need to troubleshoot recent issues in my project. Perform the following autonomous loop:

Step 1 : Retrieval: Use the Logging MCP to fetch the 5 most recent ERROR entries from the log 'mcp-scenario-logger'.
Step 2 : Iteration: For every unique error found, extract the service and specific error message.
Step 3 : Research: Use the Developer Knowledge MCP to find the official resolution or gcloud command to fix each issue.
Step 4 : Resolution: Consolidate everything into a markdown table with columns: | Service | Error Summary | Recommended Fix |.

O que esperar

Você está assistindo um fluxo de trabalho agêntico em tempo real. O agente vai:

  1. Chame list_log_entries para ver o "Dia ruim" que acabamos de simular.
  2. Analise o texto para identificar que o GCS, o Cloud Run e o Secret Manager estão falhando.
  3. Chame search_documents e get_document para cada um desses serviços e encontre os papéis do IAM ou as correções de configuração corretos.
  4. Apresentar uma tabela estruturada semelhante a esta (as recomendações podem ser diferentes):

Serviço

Resumo do erro

Correção recomendada

Cloud Storage

403 Proibido no upload

Conceda roles/storage.objectCreator à conta de serviço.

Cloud Run

Falha ao detectar a porta 8080

Verifique se o app se vincula a 0.0.0.0 na porta definida por $PORT.

Secret Manager

Função de acesso à versão ausente

Atribua roles/secretmanager.secretAccessor à identidade.

6. Jornada C: os dados (MCP do Firestore)

Nesta jornada, você vai usar o servidor MCP do Firestore para gerenciar um banco de dados de documentos NoSQL usando apenas linguagem natural.

O Firestore é um banco de dados flexível e escalonável, mas o gerenciamento dele geralmente exige a gravação de código complexo do SDK ou a navegação no console. Com o MCP, seu agente se torna um administrador de banco de dados, capaz de inserir dados, consultar registros e até mesmo realizar migrações complexas de esquemas por chat.

Tarefa 1: ativar os serviços do Firestore

Primeiro, ative a API Firestore e o endpoint do MCP correspondente.

# 1. Enable the Firestore API
gcloud services enable firestore.googleapis.com

# 2. Enable the MCP Server interface
gcloud beta services mcp enable firestore.googleapis.com

Tarefa 2: atribuir papéis do IAM do Firestore

Para executar consultas, sua identidade precisa de permissões específicas além do acesso básico ao MCP.

# Grant Firestore User role
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/datastore.user"

Tarefa 3: criar um banco de dados de teste dedicado

Para manter nossos experimentos seguros, vamos criar um banco de dados dedicado do Firestore chamado mcp-lab-db.

gcloud firestore databases create --database=mcp-lab-db --location=nam5 --type=firestore-native

Tarefa 4: configurar a CLI do Gemini

Adicione o servidor MCP do Firestore ao seu agente. Adicione a seguinte configuração à seção "mcpServers" no arquivo ~/.gemini/settings.json. Substitua YOUR_PROJECT_ID pelo ID do projeto:

"firestore-mcp": {
      "httpUrl": "https://firestore.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/cloud-platform"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
}

Tarefa 5: operações de banco de dados em linguagem natural

Inicie a CLI do Gemini e faça algumas operações básicas para verificar a conexão.

Inicie a CLI do Gemini:

gemini

Verifique se o servidor está pronto: digite /mcp list. Você vai ver firestore-mcp com várias ferramentas (add_document, create_database, list_documents, etc).

Tente estes comandos em ordem:

Inserir dados:

In the 'mcp-lab-db' database, add three documents to a 'products' collection. Include a laptop (stock 5), a mouse (stock 25), and a keyboard (stock 8).

Verificar:

List all documents in the 'products' collection from the 'mcp-lab-db' database.

Teste outros comandos que ajudam você a gerenciar bancos de dados e coleções do Firestore usando linguagem natural.

7. Jornada D: inteligência (BigQuery e Maps)

Nesta jornada, você vai equipar seu agente com a capacidade de analisar petabytes de dados e entender o mundo físico usando os servidores MCP do BigQuery e do Maps Grounding Lite.

Ao final desta seção, seu agente poderá traduzir linguagem natural em consultas SQL complexas e fornecer conselhos geoespaciais contextualizados (como tempos de viagem e clima) para fundamentar as respostas na realidade.

Tarefa 1: ativar os serviços de inteligência

Ative as APIs e interfaces do MCP para o BigQuery e o Google Maps.

# 1. Enable product APIs
gcloud services enable bigquery.googleapis.com mapstools.googleapis.com

# 2. Enable MCP Server interfaces
gcloud beta services mcp enable bigquery.googleapis.com
gcloud beta services mcp enable mapstools.googleapis.com

Tarefa 2: atribuir papéis do IAM do BigQuery

Para executar consultas, sua identidade precisa de permissões específicas além do acesso básico ao MCP.

# Grant BigQuery Job User and Data Viewer roles
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/bigquery.jobUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="user:$USER_EMAIL" \
    --role="roles/bigquery.dataViewer"

Tarefa 3: provisionar uma chave de API do Maps

Ao contrário de outros serviços que dependem apenas do IAM, o servidor do Maps Grounding Lite exige uma chave de API para cota e faturamento.

Crie a chave:

gcloud alpha services api-keys create --display-name="MCP-Maps-Key"

Extraia a string de chave:

# Wait a few seconds for the key to propagate, then fetch the string
gcloud alpha services api-keys get-key-string \
    $(gcloud alpha services api-keys list \
    --filter="displayName='MCP-Maps-Key'" \
    --format="value(name)") \
    --format="value(keyString)"

Copie a string da chave para a próxima etapa.

Tarefa 4: configurar a CLI do Gemini

Agora, registre os dois servidores. Adicione os snippets abaixo à seção mcpServers do arquivo ~/.gemini/settings.json. Substitua YOUR_PROJECT_ID e YOUR_MAPS_API_KEY de acordo com a situação.

"bigquery-mcp": {
      "httpUrl": "https://bigquery.googleapis.com/mcp",
      "authProviderType": "google_credentials",
      "oauth": {
        "scopes": [
          "https://www.googleapis.com/auth/cloud-platform"
        ]
      },
      "timeout": 30000,
      "headers": {
        "x-goog-user-project": "YOUR_PROJECT_ID"
      }
},
"maps-grounding-lite-mcp": {
      "httpUrl": "https://mapstools.googleapis.com/mcp",
      "headers": {
        "X-Goog-Api-Key": "YOUR_MAPS_API_KEY"
      }
}

Tarefa 5: inteligência em ação

Inicie a CLI do Gemini e teste os novos recursos de "Inteligência".

gemini

Verifique se o servidor está pronto: digite /mcp list. Você vai ver bigquery-mcp e maps-grounding-lite-mcp com várias ferramentas listadas. .

Cenário 1: o Analytical Engine (BigQuery). Peça ao agente para consultar um conjunto de dados público sem que você saiba nada de SQL:

Run a query to count the number of penguins on each island in the BigQuery public dataset ml_datasets.penguins.

Cenário 2: contexto geoespacial (Mapas) Peça ao agente para planejar uma viagem no mundo real:

I am planning a drive from Mumbai to Pune tomorrow morning. Based on current weather and routing, what should I expect in terms of travel time and what should I carry?

O que procurar:

  • Para o BigQuery, o agente vai chamar execute_sql para descobrir o esquema e executar a consulta.
  • Para o Maps, ele vai orquestrar lookup_weather e compute_routes para oferecer um plano de viagem útil e fundamentado.

8. Reforço da proteção: segurança de produção e IAM

Nesta etapa final, você vai passar de permissões amplas de "Proprietário" para um modelo de defesa em profundidade de nível de produção.

Os agentes de IA são "úteis" por natureza. Se você restringir uma ferramenta no nível da interface, um agente inteligente poderá tentar ignorar essa restrição executando um comando de shell. Para proteger de verdade sua infraestrutura, crie limites rígidos usando o Google Cloud IAM.

O modelo de segurança de duas camadas

Para executar qualquer ação, um agente precisa passar por dois portões:

  1. Etapa 1 (o portão do MCP): a identidade tem roles/mcp.toolUser? (permissão para usar o protocolo).
  2. Gate 2 (o gate de serviço): a identidade tem a função específica do produto (por exemplo, roles/datastore.viewer)? (Permissão para ver os dados).

Tarefa 1: camada 1: filtragem do lado do cliente (excludeTools)

A primeira camada de defesa é ocultar ferramentas do agente para que ele nem "pense" em usá-las.

  1. Abra as configurações da CLI do Gemini no editor do Cloud Shell:
cloudshell edit ~/.gemini/settings.json
  1. Encontre o bloco firestore-mcp e adicione a diretiva excludeTools para ocultar ações destrutivas:
"firestore-mcp": {
  "httpUrl": "https://firestore.googleapis.com/mcp",
  "excludeTools": ["delete_database", "update_database", "delete_document"],
  ...
}

Salve o arquivo e reinicie a CLI do Gemini. Execute /mcp list e observe que essas ferramentas desapareceram.

Tarefa 2: camada 2: supremacia da infraestrutura (o segurança do IAM)

A filtragem do lado do cliente é uma proteção "leve". Se você pedir ao agente para "Excluir meu banco de dados do Firestore" e a ferramenta estiver oculta, ela poderá tentar executar gcloud firestore databases delete. Para evitar isso, usamos uma conta de serviço com privilégios mínimos.

Criar uma conta de serviço somente leitura:

# Create the service account
gcloud iam service-accounts create mcp-reader-sa --display-name="MCP Reader Only"

# Grant ONLY the necessary roles (Gate 1 + Gate 2)
export PROJECT_ID=$(gcloud config get-value project)
SA_EMAIL="mcp-reader-sa@$PROJECT_ID.iam.gserviceaccount.com"

gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/mcp.toolUser"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/datastore.viewer"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/aiplatform.user"

Gerar e ativar a chave:

gcloud iam service-accounts keys create reader-key.json --iam-account=$SA_EMAIL
export GOOGLE_APPLICATION_CREDENTIALS=$(pwd)/reader-key.json

Tarefa 3: o teste de rejeição do "Agente útil"

Agora, vamos testar se o agente consegue burlar nossa segurança.

A primeira etapa é ativar a conta de serviço para que, mesmo que o agente volte a usar o comando gcloud, ele opere com a identidade da conta de serviço que acabamos de criar.

Ative a conta de serviço:

Execute o comando a seguir, substituindo [PATH_TO_KEY_FILE] pelo caminho real do arquivo de chave JSON (por exemplo, reader-key.json).

gcloud auth activate-service-account --key-file=[PATH_TO_KEY_FILE]

Verificar a mudança:

Depois de executar o comando, verifique se a conta de serviço está ativa executando:

gcloud auth list

A saída vai mostrar a conta de serviço como a credencial ativa.

Iniciar a CLI do Gemini:

gemini

Digite este comando:

I want to delete the 'mcp-lab-db' firestore database. If the tool is missing, try using the gcloud firestore command in the terminal.

O que acontece?

  1. Primeiro, o agente vai tentar usar a ferramenta delete_database no servidor MCP do Firestore. Ele vai falhar por falta de permissão.
  2. Em seguida, ele tenta ser "útil" voltando à ferramenta run_shell_command para usar o comando gcloud firestore.

O resultado

O comando falha com um erro "Proibido". Como o agente está sendo executado com a identidade mcp-reader-sa, ele não tem a permissão datastore.databases.delete. O IAM é a proteção final. Não importa como o agente tente acessar o recurso, o "Bouncer" no nível da API do Google Cloud vai bloquear a solicitação.

Mude de volta para sua conta de usuário:

Para voltar à sua conta de usuário, execute o seguinte comando:

gcloud config set account YOUR_EMAIL_ADDRESS

9. Limpeza

Para evitar cobranças indesejadas, exclua os recursos de teste:

# Delete the Firestore database
gcloud firestore databases delete --database=mcp-lab-db

# Remove the service account
gcloud iam service-accounts delete mcp-reader-sa@$PROJECT_ID.iam.gserviceaccount.com

10. Conclusão

Parabéns! Você navegou com sucesso na pilha completa dos servidores MCP gerenciados pelo Google.

Você começou com o "tronco" do laboratório, estabelecendo uma conexão fundamental com o Cloud Logging. De lá, você passou para "Aventuras" modulares, embasando o conhecimento do seu agente, automatizando loops complexos de solução de problemas, migrando dados no Firestore e extraindo inteligência do BigQuery e do Maps.

E o mais importante: você terminou ancorando seu agente nas raízes da segurança de produção. Você provou que, embora um agente possa ser "útil" demais, o IAM do Google Cloud é o segurança definitivo, garantindo que seus fluxos de trabalho autônomos sempre respeitem o princípio de privilégio mínimo.

Pontos-chave

  • Gerenciado = escalonável:você se conectou a ferramentas no nível da infraestrutura via HTTP transmitível sem implantar um único servidor.
  • Embasamento é obrigatório:você substituiu o "achismo" do LLM pelo MCP de conhecimento do desenvolvedor, garantindo que seu agente use comandos atuais e válidos.
  • Orquestração é poder:você viu que a verdadeira mágica acontece quando um agente combina vários servidores MCP para resolver um único problema de negócios.