Workshop sobre IA de ponta a ponta

1. O que você vai aprender

Full stack de vibe do agente de IA

Olá! Você vai aprender a próxima habilidade essencial no desenvolvimento de software: como orientar a inteligência artificial de maneira eficaz para criar, testar e implantar software de nível de produção. A IA generativa não é um "piloto automático", mas sim um copiloto poderoso que precisa de um diretor qualificado.

Este workshop oferece uma metodologia estruturada e repetível para fazer parceria com a IA em todas as etapas do ciclo de vida de desenvolvimento de software (SDLC) profissional. Você vai deixar de ser um programador linha por linha para se tornar um diretor técnico, um arquiteto com uma visão e um contratante geral que usa a IA para executar essa visão com precisão. 🚀

Ao final deste tutorial, você terá:

• Transformei uma ideia de alto nível em uma arquitetura de nuvem usando IA.
• Geramos um back-end Python completo com comandos específicos e segmentados.
• Usou a IA como um programador auxiliar para depurar e corrigir código.
• Delegou a criação de testes de unidade, incluindo simulações, para a IA.
• Gerou infraestrutura como código (IaC) pronta para produção com o Terraform.
• Criamos um pipeline de CI/CD completo no GitHub Actions com um único comando.
• Monitorou e gerenciou seu aplicativo ativo usando ferramentas operacionais com tecnologia de IA.

Você vai sair do evento não apenas com um app funcionando, mas com um projeto para desenvolvimento aumentado por IA. Vamos começar.

2. Pré-requisitos e configuração

Antes de começar, vamos preparar seu ambiente. Essa é uma etapa crucial para garantir uma experiência tranquila no workshop.

Criar uma conta do GCP e vincular o faturamento

Para alimentar nossos agentes de IA, precisamos de duas coisas: um projeto do Google Cloud para fornecer a base e uma chave de API do Gemini para acessar os modelos avançados do Google.

Etapa 1: ativar a conta de faturamento

• Reivindique sua conta de faturamento com um crédito de US$ 5, que será necessário para a implantação. Verifique sua conta do Gmail.

Não é preciso cartão de crédito nem pagamento: você vai receber US $5 em créditos sem custo financeiro. Leva menos de dois minutos. Basta inserir seu nome e aceitar os créditos.

Etapa 2: criar um projeto do GCP

• Acesse o Console do Google Cloud e crie um projeto.

• Abra o painel à esquerda, clique em Billing e verifique se a conta de faturamento está vinculada a essa conta do GCP.

Se você vir esta página, verifique o manage billing account, escolha o teste do Google Cloud One e vincule a ele.

Etapa 3: gerar sua chave da API Gemini

Antes de proteger a chave, você precisa ter uma.

• Acesse o Google AI Studio : https://aistudio.google.com/
• Faça login com sua conta do Gmail.
• Clique no botão Receber chave de API, geralmente encontrado no painel de navegação à esquerda ou no canto superior direito.
• Na caixa de diálogo Chaves de API, clique em "Criar chave de API em um novo projeto".
• Escolha o novo projeto que você criou e que tem uma conta de faturamento configurada.
• Uma nova chave de API será gerada para você. Copie essa chave imediatamente e armazene-a temporariamente em um lugar seguro, como um gerenciador de senhas ou uma nota segura. Esse é o valor que você vai usar nas próximas etapas.

Autenticação do GitHub

Use a mesma conta do Gmail no GitHub e no projeto do Google Cloud.

Abra o Cloud Shell acessando o Console do Google Cloud e clicando no botão "Ativar Cloud Shell" no canto superior direito.

Etapa 1: abrir o Cloud Shell

👉Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud. É o ícone em forma de terminal na parte de cima do painel do Cloud Shell.

👉Clique no botão "Abrir editor" (parece uma pasta aberta com um lápis). Isso vai abrir o editor de código do Cloud Shell na janela. Um explorador de arquivos vai aparecer no lado esquerdo.

👉Depois de abrir o editor, abra o terminal no IDE da nuvem.

👉💻 No terminal, verifique se você já está autenticado e se o projeto está definido como seu ID do projeto usando o seguinte comando:

gcloud auth list

Etapa 2: autenticar com o GitHub e fazer um fork

Autenticar com o GitHub:

👉💻 Copie e cole o comando no terminal da nuvem:

gh auth login

• Em "Onde você usa o GitHub", escolha "GitHub.com".
• "Qual é o protocolo de sua preferência para operações do Git neste host?", escolha "HTTPS"
• "Autenticar o Git com suas credenciais do GitHub?", escolha "Sim"
• "Como você quer autenticar a CLI do GitHub?", escolha "Fazer login com um navegador da Web".

Importante: não pressione "Enter" ainda

Copie e cole o link do terminal para abrir a página de autenticação do GitHub.

copie o código do terminal para a página de verificação de login

Depois de inserir o código, volte ao terminal do Cloud Shell e pressione "Enter" para continuar.

Etapa 4: fazer fork e clonar o repositório

👉💻 Copie e cole o comando no terminal da nuvem:

gh repo fork cuppibla/storygen-learning --clone=true

3. Arquitetura: da ideia ao blueprint com o Cloud Assist

Todo projeto incrível começa com uma visão clara. Vamos usar nosso copiloto de IA, o Cloud Assist, para projetar a arquitetura do app.

Ações

• Abra o console do Google Cloud: [https://console.cloud.google.com](Google Cloud Console)
• No canto superior direito, clique em "Abrir o chat da Assistente do Cloud".

Ativar o Cloud Assist

• Clique em Get Gemini Assist e em Enable Cloud Assist at no cost.
• E comece a conversar!

Forneça o seguinte comando detalhado ao Cloud Assist:

Insira sua ideia

Generate a Python web application that uses AI to generate children's stories and illustrations. It has Python backend and React frontend host separately on Cloudrun. They communicate through Websocket. It needs to use a generative model for text and another for images. The generated images must be used by Imagen from Vertex AI and stored in a Google Cloud Storage bucket so that frontend can fetch from the bucket to render images. I do not want any load balancer or a database for the story text. We need a solution to store the API key.

Receber o projeto do seu app

• Clique em "Editar design do app" para ver o diagrama. Clique no painel superior direito "<> Receber código" para baixar o código do Terraform.
• O Cloud Assist vai gerar um diagrama de arquitetura. Este é nosso blueprint visual.

Nenhuma ação é necessária com este código. Leia abaixo para mais explicações

Entender o código do Terraform gerado Você acabou de receber um conjunto completo de arquivos do Terraform da Assistência do Cloud. Por enquanto, nenhuma ação é necessária com esse código, mas vamos explicar rapidamente o que ele é e por que é tão eficiente.

O que é o Terraform? O Terraform é uma ferramenta de infraestrutura como código (IaC). Pense nisso como um blueprint do seu ambiente de nuvem, escrito em código. Em vez de clicar manualmente no console do Google Cloud para criar serviços, armazenamento e permissões, você define todos esses recursos nesses arquivos de configuração. Em seguida, o Terraform lê seu blueprint e cria esse ambiente exato para você automaticamente.

Do plano visual ao código executável. O diagrama de arquitetura fornecido pelo Cloud Assist é seu plano visual. O código do Terraform é a versão legível por máquina desse mesmo plano. É o link essencial que transforma um conceito de design em uma realidade reproduzível e automatizada. Ao definir sua infraestrutura em código, é possível:

• Criação automática: crie o mesmo ambiente de forma confiável várias vezes.
• Use o controle de versões: acompanhe as mudanças na sua infraestrutura no Git, assim como no código do aplicativo.
• Evitar erros: evite os erros manuais que podem acontecer ao clicar em uma interface da Web.

Neste workshop, não é necessário executar o código do Terraform. Pense nisso como o blueprint profissional, o "gabarito" da infraestrutura que você vai criar e implantar nas próximas etapas.

4. Desenvolvimento: introdução à CLI do Gemini

👉💻 No terminal do Cloud Shell, navegue até seu diretório pessoal.

cd ~/storygen-learning

👉💻 Teste o Gemini pela primeira vez.

clear
gemini --model=gemini-2.5-flash

Se perguntar Do you want to connect Cloud Shell editor to Gemini CLI?, escolha NÃO.

👉✨ Todas as ferramentas do Gemini têm uma descrição. Leia agora. No comando do Gemini, digite:

Na CLI do Gemini

/help

👉✨ A CLI do Gemini tem um conjunto próprio de recursos integrados. Para inspecionar:

Na CLI do Gemini

/tools

Você vai ver uma lista com ReadFile, WriteFile e GoogleSearch. Essas são as técnicas padrão que você pode usar sem precisar recorrer a um arsenal externo.

👉✨ A lâmina do Gemini pode manter a "consciência tática" (contexto) para orientar as ações.

Na CLI do Gemini

/memory show

No momento, ele está vazio, como uma tela em branco.

👉✨ Primeiro, adicione uma personalidade à memória do agente. Isso vai definir a área de especialidade:

Na CLI do Gemini

/memory add "I am master at python development"

Execute /memory show novamente para confirmar que sua ferramenta absorveu esse conhecimento.

👉✨ Para demonstrar como referenciar arquivos com o símbolo @, primeiro vamos criar um arquivo de "briefing da missão".

Abra um novo terminal e execute o seguinte comando para criar o arquivo da missão:

!echo "## Mission Objective: Create Imagen ADK Agent for Story Book" > mission.md

👉✨Agora, peça à CLI do Gemini para analisar o briefing e informar as descobertas:

Na CLI do Gemini

Explain the contents of the file @mission.md

Sua arma principal agora sabe qual é o objetivo.

👉💻 Pressione Ctrl+C duas vezes para sair da CLI do Gemini

Aprendizado:

Como a CLI Gemini ganha superpoderes: gemini.md. Antes de continuar, é importante entender como a CLI Gemini pode ser adaptada a um projeto específico. Embora seja possível usar como uma ferramenta de chat de uso geral, o verdadeiro poder dela vem de um arquivo de configuração especial: gemini.md.

Quando você executa o comando gemini, ele procura automaticamente um arquivo gemini.md no diretório atual. Esse arquivo funciona como um manual de instruções específico do projeto para a IA. Ela pode definir três coisas principais:

• Personagem: você pode dizer à IA quem ela deve ser. Por exemplo, "Você é um desenvolvedor Python especializado em Google Cloud". Isso foca as respostas e o estilo.
• Ferramentas: você pode dar acesso a arquivos específicos (@file.py) ou até mesmo a pesquisas do Google (@google). Isso fornece à IA o contexto necessário para responder a perguntas sobre o código do seu projeto.
• Memória: você pode fornecer fatos ou regras que a IA precisa sempre lembrar para este projeto, o que ajuda a manter a consistência.

Ao usar um arquivo gemini.md, você transforma o modelo genérico do Gemini em um assistente especializado que já conhece as metas do seu projeto e tem acesso às informações certas.

5. Desenvolvimento: como criar o ADK com a CLI do Gemini

Configuração inicial

Use a CLI do Gemini para fazer um fork do repositório e preparar o espaço de trabalho:

Configuração do ambiente

Acesse o Cloud Shell e clique no botão "Abrir terminal".

1. Copie o modelo de ambiente:

   cd ~/storygen-learning
   cp ~/storygen-learning/env.template ~/storygen-learning/.env
   

Ver arquivo oculto no editor se não encontrar .env

• Clique em Visualizar na barra de menus superior.
• Selecione Alternar arquivos ocultos.

👉Encontre o ID do projeto do Google Cloud:

• Abra o console do Google Cloud: link
• Selecione o projeto que você quer usar neste workshop no menu suspenso na parte de cima da página.
• O ID do projeto é exibido no card "Informações do projeto" no painel.

👉Encontre seu nome de usuário do GitHub:

• Acesse o GitHub e encontre seu nome de usuário.

Edite o arquivo .env. Substitua os seguintes valores em .env:

GOOGLE_API_KEY=[REPLACE YOUR API KEY HERE]
GOOGLE_CLOUD_PROJECT_ID=[REPLACE YOUR PROJECT ID]
GITHUB_USERNAME=[REPLACE YOUR USERNAME]
GENMEDIA_BUCKET=[REPLACE YOUR PROJECT ID]-bucket

Por exemplo, se o ID do projeto for testproject, coloque GOOGLE_CLOUD_PROJECT_ID=testproject e GENMEDIA_BUCKET=testproject-bucket.

Scripts de configuração

Acesse 00_Starting_Here. Abra um novo terminal (não na CLI do Gemini).

cd ~/storygen-learning/00_Starting_Here

Execute a configuração completa:

./setup-complete.sh

Os resultados da configuração vão aparecer no terminal

Criar seu primeiro agente

Acesse 01a_First_Agent_Ready. Vamos usar a CLI do Gemini para criar o agente do ADK:**

cd ~/storygen-learning/01a_First_Agent_Ready

Abrir a CLI do Gemini

gemini

Na janela da CLI do Gemini, tente o comando:

I need you to help me create a Google ADK (Agent Development Kit) agent for story generation. I'm working on a children's storybook app that generates creative stories with visual scenes.

Please create a complete `agent.py` file that implements an LlmAgent using Google's ADK framework. The agent should:

**Requirements:**
1. Use the `google.adk.agents.LlmAgent` class
2. Use the "gemini-2.5-flash" model (supports streaming)
3. Be named "story_agent"
4. Generate structured stories with exactly 4 scenes each
5. Output valid JSON with story text, main characters, and scene data
6. No tools needed (images are handled separately)

**Agent Specifications:**
- **Model:** gemini-2.5-flash
- **Name:** story_agent  
- **Description:** "Generates creative short stories and accompanying visual keyframes based on user-provided keywords and themes."
**Story Structure Required:**
- Exactly 4 scenes: Setup → Inciting Incident → Climax → Resolution
- 100-200 words total
- Simple, charming language for all audiences
- Natural keyword integration
**JSON Output Format:**

{
  "story": "Complete story text...",
  "main_characters": [
    {
      "name": "Character Name",
      "description": "VERY detailed visual description with specific colors, features, size, etc."
    }
  ],
  "scenes": [
    {
      "index": 1,
      "title": "The Setup",
      "description": "Scene action and setting WITHOUT character descriptions",
      "text": "Story text for this scene"
    }
    // ... 3 more scenes
  ]
}


**Key Instructions for the Agent:**
- Extract 1-2 main characters maximum
- Character descriptions should be extremely detailed and visual
- Scene descriptions focus on ACTION and SETTING only
- Do NOT repeat character appearance in scene descriptions
- Always respond with valid JSON

Please include a complete example in the instructions showing the exact format using keywords like "tiny robot", "lost kitten", "rainy city".

The file should start with necessary imports, define an empty tools list, include a print statement for initialization, and then create the LlmAgent with all the detailed instructions.

Can you create this agent in backend/story_agent/agent.py

Quando terminar, desative o terminal da CLI do Gemini com Control+C

—————————————— Opcional, você pode pular para a parte Solução ——————————————–

Agora verifique sua mudança na ADK Web

cd ~/storygen-learning/01a_First_Agent_Ready/backend

source ../../.venv/bin/activate

adk web --port 8080

Para continuar, você vai precisar de um prompt de comando.

Abra uma nova janela de terminal ou interrompa o servidor da Web do ADK atual pressionando Ctrl+C.

Ativar o site

cd ~/storygen-learning/01a_First_Agent_Ready

./start.sh

Se a mudança não funcionar, você vai encontrar erros na interface da Web e no site do ADK.

——————————————– Solução começa aqui ——————————————–

Solução

Encerre o processo anterior com Control+C ou abra outro terminal:

cd ~/storygen-learning/01b_First_Agent_Done

Ativar o site:

./start.sh

O site vai aparecer:

Teste a interface do ADK:abra outro terminal:

cd ~/storygen-learning/01b_First_Agent_Done/backend

source ../../.venv/bin/activate

adk web --port 8080

A interface do ADK vai aparecer, e você poderá fazer perguntas ao agente.

Antes de passar para a próxima seção, pressione Ctrl+C para encerrar o processo.

6. Desenvolvimento: crie seu agente personalizado com o Imagen

Gerar a ferramenta Imagen (segundo agente)

cd ~/storygen-learning/02a_Image_Agent_Ready

Use a CLI Gemini para criar o agente de geração de imagens:

gemini generate "I need you to help me create a custom Google ADK (Agent Development Kit) agent for image generation. This is different from the story agent - this one handles image generation directly using the BaseAgent pattern for full control over tool execution.

Please create a complete `agent.py` file that implements a custom image generation agent. The agent should:

**Requirements:**
1. Use the `google.adk.agents.BaseAgent` class (NOT LlmAgent)
2. Be named "custom_image_agent" 
3. Directly execute the ImagenTool without LLM intermediation
4. Handle JSON input with scene descriptions and character descriptions
5. Store results in session state for retrieval by main.py
6. Use async generators and yield Events

**Key Specifications:**
- **Class Name:** CustomImageAgent (inherits from BaseAgent)
- **Agent Name:** "custom_image_agent"
- **Tool:** Uses ImagenTool for direct image generation
- **Purpose:** Bypass LLM agent limitations and directly call ImagenTool

**Input Format:**
The agent should handle JSON input like:
{
  "scene_description": "Scene action and setting",
  "character_descriptions": {
    "CharacterName": "detailed visual description"
  }
}


**Core Method:** `async def _run_async_impl(self, ctx: InvocationContext) -> AsyncGenerator[Event, None]:`
   - Extract user message from `ctx.user_content.parts`
   - Parse JSON input or fallback to plain text
   - Extract scene_description and character_descriptions
   - Build image prompt with style prefix: "Children's book cartoon illustration with bright vibrant colors, simple shapes, friendly characters."
   - Include character descriptions for consistency
   - Call `await self.imagen_tool.run()` directly
   - Store results in `ctx.session.state["image_result"]`
   - Yield Event with results


 **Session State:**
   - Store JSON results in `ctx.session.state["image_result"]`
   - Include success/error status
   - Store actual image URLs or error messages

Expected Output Structure:
- Successful results stored as JSON with image URLs
- Error results stored as JSON with error messages
- Results accessible via session state in main.py

Can you create this agent in backend/story_image_agent/agent.py

"

—————————————— Opcional, você pode pular para a parte Solução ——————————————–

Agora verifique sua mudança na ADK Web

cd ~/storygen-learning/02a_Image_Agent_Ready/backend

source ../../.venv/bin/activate

adk web --port 8080

Ativar o site

cd ~/storygen-learning/02a_Second_Agent_Ready

./start.sh

Se a mudança não funcionar, você vai encontrar erros na interface da Web e no site do ADK.

—————————————- A solução começa aqui ——————————————–

Solução

Encerre o processo anterior com Control+C ou abra outro terminal:

# Open new terminal
cd ~/storygen-learning/02b_Image_Agent_Done

Ativar o site:

./start.sh

O site vai aparecer:

Teste a interface do ADK:abra outro terminal:

# Open new terminal
cd ~/storygen-learning/02b_Image_Agent_Done/backend

source ../../.venv/bin/activate

adk web --port 8080

A interface do ADK vai aparecer, e você poderá fazer perguntas ao agente:

Antes de passar para a próxima seção, pressione Ctrl+C para encerrar o processo.

Aprendizado

Nosso primeiro agente era ótimo para gerar texto, mas agora precisamos gerar imagens. Para essa tarefa, precisamos de um controle mais direto. Não queremos que o LLM decida se vai criar uma imagem. Queremos comandar isso diretamente. Esse é o trabalho perfeito para um BaseAgent.

Ao contrário do LlmAgent declarativo, um BaseAgent é imperativo. Isso significa que você, o desenvolvedor, escreve a lógica exata do Python etapa por etapa dentro do método _run_async_impl. Você tem controle total sobre o fluxo de execução.

Escolha um BaseAgent quando precisar:

Lógica determinística: o agente precisa seguir uma sequência de etapas específica e imutável.

Execução direta de ferramentas: você quer chamar uma ferramenta diretamente sem intervenção do LLM.

Fluxos de trabalho complexos: o processo envolve manipulação de dados personalizados, chamadas de API e lógica muito complexa para um LLM inferir de um comando sozinho.

No nosso app, vamos usar um BaseAgent para receber as descrições de cena do primeiro agente e chamar diretamente a ferramenta Imagen para garantir que uma imagem seja gerada para cada cena.

7. Teste: avaliação de agentes

Nosso app funciona, mas precisamos de uma rede de segurança automatizada de testes. Essa é uma tarefa perfeita para delegar ao nosso copiloto de IA.

Ações

cd ~/storygen-learning/03a_Agent_Evaluation_Ready/backend

Use a CLI do Gemini para escrever testes abrangentes:

Abrir a CLI do Gemini

gemini

Na janela da CLI do Gemini, tente o comando:

I need you to create comprehensive test files for my backend/story_agent in Google ADK. I need three specific JSON files that match the testing structure used in ADK evaluation.

**Context:** 
- The story agent generates structured JSON stories with exactly 4 scenes
- It uses LlmAgent with no tools, just direct LLM responses
- Input: Keywords
- Output: JSON with story, main_characters, and scenes arrays

**Files to Create:**

### 1. `story_agent_eval.evalset.json` (Comprehensive Integration Tests)
Create a comprehensive evaluation set with:
- **eval_set_id**: "story_agent_comprehensive_evalset"
- **name**: "Story Agent Comprehensive Evaluation Set" 
- **description**: "Comprehensive evaluation scenarios for story_agent covering various keyword combinations, edge cases, and story quality metrics"


Each eval_case should include:
- Full conversation arrays with invocation_id, user_content, final_response
- Complete expected JSON responses with detailed stories, characters, and 4 scenes
- session_input with app_name "story_agent"
- All fields: story (narrative text), main_characters (with detailed visual descriptions), scenes (with index, title, description, text)

### 2. `story_generation.test.json` (Unit Tests)
Create basic generation tests with:
- **eval_set_id**: "story_agent_basic_generation_tests"
- **name**: "Story Agent Basic Generation Tests"
- **description**: "Unit tests for story_agent focusing on JSON structure compliance, scene generation, and keyword integration"

### 3. `test_config.json` (Evaluation Configuration)
Create test configuration with:
- **criteria**: response_match_score: 0.7, tool_trajectory_avg_score: 1.0
- **custom_evaluators**: 
  - json_structure_validator (validates required fields, scene count, character fields)
  - story_quality_metrics (word count 80-250, keyword integration threshold 0.8)
- **evaluation_notes**: Story agent specifics and trajectory expectations

**Important Requirements:**
1. All responses must be valid, parseable JSON
2. Stories must have exactly 4 scenes with indices 1-4
3. Each scene must have: index, title, description, text
4. Main characters must have detailed visual descriptions
5. No tool_uses expected (empty arrays) since story agent uses direct LLM
6. Word count should be 100-200 words total
7. Keywords must be naturally integrated into the narrative

Please generate all three files with realistic example stories and comprehensive test coverage matching the ADK evaluation format.

—————————————— Opcional, você pode pular para a parte Solução ——————————————–

Para ver a avaliação:

./run_adk_web_persistent.sh

Acesse a guia eval na interface do ADK.

Você vai ver a interface da Web do ADK com recursos de teste persistentes.

Momento de aprendizado principal:a IA é uma parceira poderosa na automação do controle de qualidade. Ele pode lidar com o texto clichê da criação de testes, liberando você para se concentrar na criação de recursos.

——————————————– Solução começa aqui ——————————————–

Solução

• Acesse a pasta da solução:

cd ~/storygen-learning/03b_Agent_Evaluation_Done/backend

• Abrir a interface da Web do ADK

./run_adk_web_persistent.sh

É possível conferir os casos de teste na guia Eval:

Ajuste as métricas aqui:

Confira o resultado da execução da avaliação aqui:

Aprendizado

Um agente pode "funcionar" sem erros, mas como saber se ele está produzindo a saída certa? A história é boa? O formato JSON está correto? É aqui que entra a estrutura de avaliação do ADK.

A avaliação de agentes é um sistema de teste automatizado projetado para medir a qualidade e a correção das respostas do seu agente. Em vez de apenas verificar erros de código, ele verifica se o comportamento do agente atende às suas expectativas. O framework usa principalmente alguns arquivos principais:

evalset.json: é o conjunto de testes principal. Cada "caso de avaliação" dentro desse arquivo contém uma conversa de exemplo (por exemplo, um comando do usuário) e a resposta ideal, "de ouro", que você espera que o agente produza.

test_config.json: define as regras para o sucesso. Você define critérios aqui, como:

response_match_score: qual é o nível de correspondência necessário entre a resposta do agente e a resposta "ideal"? Uma pontuação de 1,0 significa que eles precisam ser idênticos.

custom_evaluators: você pode criar suas próprias regras, como "A resposta precisa ser um JSON válido" ou "A história precisa ter mais de 100 palavras".

Ao executar uma avaliação, você pode testar automaticamente seu agente em dezenas de cenários, garantindo que as mudanças no comando ou nas ferramentas não prejudiquem acidentalmente a funcionalidade principal. É uma rede de segurança eficiente para criar agentes de IA prontos para produção.

8. Infraestrutura como código (IaC): como construir uma casa na nuvem

Nosso código é testado, mas precisa de um ambiente pronto para produção. Vamos usar a "infraestrutura como código" para definir nosso ambiente.

O que é o Docker?

O Docker é uma plataforma para criar e executar aplicativos em contêineres. Pense em um contêiner como um contêiner de transporte padronizado para software. Ele agrupa tudo o que o aplicativo precisa para ser executado em um único pacote isolado:

• O código do aplicativo
• O ambiente de execução necessário (por exemplo, a versão específica do Python)
• Todas as ferramentas e bibliotecas do sistema

Esse aplicativo conteinerizado pode ser executado em qualquer máquina com o Docker instalado, resolvendo o problema clássico de "funciona na minha máquina".

Nesta seção, vamos pedir ao Gemini para gerar um Dockerfile, que é simplesmente a receita ou o modelo para criar a imagem de contêiner do nosso aplicativo.

Ações

cd ~/storygen-learning/04a_Manual_Deployment_Ready

Use a CLI do Gemini para criar um Dockerfile para o back-end:abra a CLI do Gemini.

Gemini

Na CLI do Gemini, tente o comando:

Create a manual deployment plan for my StoryGen app with Google Cloud Platform. I have a Next.js frontend, Python backend, and Terraform infrastructure.

Generate these deployment files:
1. **01-setup.sh** - Environment setup and authentication
2. **02-build-images.sh** - Build and push Docker images to Google Container Registry
3. **03-deploy-infrastructure.sh** - Deploy with Terraform and configure services
4. **load-env.sh** - Load environment variables for deployment

**Requirements:**
- Use Google Cloud Run for both frontend and backend
- Configure Imagen API and storage buckets
- Set up proper IAM permissions
- Use environment variables from .env file
- Include error handling and status checks

Keep scripts simple, well-commented, and production-ready for manual execution.

Solução:

cd ~/storygen-learning/04b_Manual_Deployment_Done

Execute:

source ../.venv/bin/activate
./01-setup.sh

./02-build-images.sh

./03-deploy-infrastructure.sh

Você vai ver os resultados da implantação e a criação da infraestrutura

9. Automação (CI/CD): a linha de montagem digital

Implantar o aplicativo manualmente é uma ótima maneira de entender as partes móveis, mas é lento, exige esforço manual e pode levar a erros humanos. No desenvolvimento profissional de software, todo esse processo é automatizado usando uma prática chamada CI/CD.

CI/CD significa integração contínua e implantação contínua. É um método para criar, testar e implantar automaticamente seu código sempre que você faz uma mudança.

• Integração contínua (CI): é a fase de "criar e testar". Assim que um desenvolvedor envia uma mudança de código para um repositório compartilhado (como o GitHub), um sistema automatizado entra em ação. Ele cria o aplicativo e executa todos os testes (como as avaliações de agente que criamos) para garantir que o novo código seja integrado corretamente e não introduza bugs.
• Implantação contínua (CD): é a fase de "lançamento". Se a fase de CI for concluída com êxito, o sistema vai implantar automaticamente a nova versão testada do aplicativo em produção, disponibilizando-a para os usuários.

Esse pipeline automatizado cria uma "linha de montagem digital" que leva o código da máquina de um desenvolvedor para a produção de maneira rápida, segura e confiável. Nesta seção, vamos pedir ao nosso assistente de IA para criar essa linha de montagem usando o GitHub Actions e o Google Cloud Build.

Ações

cd ~/storygen-learning/05a_CICD_Pipeline_Ready

Use a CLI Gemini para criar seu pipeline de CI/CD com o GitHub:

Abrir a CLI do Gemini

Gemini

Na CLI do Gemini, tente o comando:

Create a CI/CD pipeline for my StoryGen app using Google Cloud Build and GitHub integration.

Generate these automation files:
1. **cloudbuild.yaml** (for backend) - Automated build, test, and deploy pipeline
2. **GitHub Actions workflow** - Trigger builds on push/PR
3. **Deployment automation scripts** - Streamlined deployment process

**Requirements:**
- Auto-trigger on GitHub push to main branch
- Build and push Docker images
- Run automated tests if available
- Deploy to Google Cloud Run
- Environment-specific deployments (staging/prod)
- Notification on success/failure

Focus on fully automated deployment with minimal manual intervention. Include proper secret management and rollback capabilities.

——————————————– Solução começa aqui ——————————————–

Solução:

cd ~/storygen-learning/06_Final_Solution/
# Copy the GitHub workflow to parent folder
cp -r 06_Final_Solution/.GitHub ../../../.GitHub

Volte para a pasta 06_Final_Solution e execute o script:

cd ~/storygen-learning/06_Final_Solution/

./setup-cicd-complete.sh

A conclusão da configuração do pipeline de CI/CD vai aparecer

Acionar o fluxo de trabalho:faça commit e push do código para main. É necessário configurar seu e-mail e nome do GitHub para permitir a permissão.

git add .
git commit -m "feat: Add backend, IaC, and CI/CD workflow"
git push origin main

Acesse a guia "Ações" no repositório do GitHub para acompanhar a execução da implantação automatizada.

10. Operações: a torre de controle de IA

Estamos ao vivo! Mas a jornada não acabou. Esse é o "Dia 2": operações. Vamos voltar ao Cloud Assist para gerenciar o aplicativo em execução.

Ações

1. Navegue até o serviço do Cloud Run no console do Google Cloud. Interaja com o app ativo para gerar tráfego e registros.
2. Abra o painel do Cloud Assist e use-o como um copiloto operacional com comandos como estes:

Análise de registros:

Summarize the errors in my Cloud Run logs for the service 'genai-backend' from the last 15 minutes.

Ajuste de desempenho:

My Cloud Run service 'genai-backend' has high startup latency. What are common causes for a Python app and how can I investigate with Cloud Trace?

Otimização de custos:

Analyze the costs for my 'genai-backend' service and its GCS bucket. Are there any opportunities to save money?

Momento de aprendizado importante:o ciclo de vida de desenvolvimento de software (SDLC, na sigla em inglês) de IA é um loop contínuo. O mesmo copiloto de IA que ajudou a criar o aplicativo é um parceiro indispensável para monitorar, resolver problemas e otimizar a produção.