Criar um gerador de testes com a IA generativa e o Cloud Run

1. Introdução

Neste laboratório, você vai criar um serviço da Web para gerar quizzes de curiosidades e integrá-lo a um app divertido e funcional. Você vai usar uma linguagem de programação diferente da que já usou: inglês.

O que você vai fazer…

Você vai criar um comando que gera um teste de curiosidades de acordo com um conjunto de critérios.
Você vai criar um app da Web simples e verificar se ele é executado conforme o esperado no ambiente de desenvolvimento.
Você vai adicionar lógica incrementalmente ao web app para transformá-lo em um servidor de API que gera testes de acordo com um conjunto de parâmetros de entrada.
Você vai ver como é fácil implantar seu serviço de geração de testes na nuvem usando o Google Cloud Run.
Por fim, você vai configurar um app real ( quizaic.com) para usar o serviço de gerador de quizzes implantado e poderá jogar quizzes ao vivo com base na saída.

O que você vai aprender…

Como criar um comando com modelo para um modelo de linguagem grande (LLM).
Como criar um app de servidor da Web simples em Python.
Como adicionar suporte ao LLM do Google no seu app da Web.
Como implantar seu app na nuvem para que qualquer pessoa possa testar sua nova criação.
Como integrar seu gerador de testes a um app maior.

O que é necessário…

Navegador da Web Google Chrome
Uma Conta do Google
Um projeto do Cloud com faturamento ativado

Este laboratório é voltado para desenvolvedores com todos os níveis de conhecimento, inclusive iniciantes. Embora você use Python, não é necessário conhecer esse tipo de programação para entender o que está acontecendo, porque vamos explicar todo o código que você vai ver.

2. Configuração

Nesta seção, você vai encontrar tudo o que precisa fazer para começar o laboratório.

Configuração de ambiente autoguiada

Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Neste laboratório, você vai trabalhar em uma sessão do Cloud Shell, que é um interpretador de comandos hospedado por uma máquina virtual em execução na nuvem do Google. A sessão também pode ser executada localmente no seu computador, mas se você usar o Cloud Shell, todas as pessoas vão ter acesso a uma experiência reproduzível em um ambiente consistente. Após concluir o laboratório, é uma boa ideia testar a sessão no seu computador.

Ativar o Cloud Shell

No Console do Cloud, clique em Ativar o Cloud Shell.

Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária vai aparecer com a descrição dele. Se isso acontecer, clique em Continuar.

Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, quase todo o trabalho pode ser feito com um navegador.

Depois de se conectar ao Cloud Shell, você vai ver que sua conta já está autenticada e que o projeto está configurado com o ID do seu projeto.

Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:

gcloud auth list

Resposta ao comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto:

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

Se o projeto não estiver configurado, configure-o usando este comando:

gcloud config set project <PROJECT_ID>

Resposta ao comando

Updated property [core/project].

Ativar algumas APIs

Nas próximas etapas, você vai entender onde e por que esses serviços são necessários. Por enquanto, apenas execute este comando para conceder ao seu projeto acesso ao Cloud Build, Artifact Registry, Vertex AI e Cloud Run:

gcloud services enable cloudbuild.googleapis.com        \
                       artifactregistry.googleapis.com  \
                       aiplatform.googleapis.com        \
                       run.googleapis.com

Uma mensagem semelhante a esta vai aparecer:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. Comandos: programação em linguagem natural

Vamos começar aprendendo a desenvolver um comando para um modelo de linguagem grande. Acesse o console do Google Cloud > Vertex AI > Vertex AI Studio (Linguagem). Você vai acessar uma página parecida com esta:

Em Generate Text, clique no botão Text Prompt. Na próxima caixa de diálogo, insira um comando que você acha que pode ser eficaz para gerar um quiz de curiosidades de acordo com os seguintes requisitos:

Tema: História mundial
Número de perguntas: 5
Nível de dificuldade: intermediário
Idioma: inglês

Clique no botão "Enviar" para ver a saída.

Como mostrado na captura de tela a seguir, o painel à direita permite selecionar o modelo que você quer usar e ajustar algumas configurações:

As seguintes configurações estão disponíveis:

A região em que sua solicitação de geração será executada.
O modelo seleciona qual modelo de linguagem grande você quer usar. Para este codelab, use "gemini-1.0-pro-001".
A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que esperam uma resposta verdadeira ou correta, e as mais altas podem gerar resultados mais diversos ou inesperados.
O limite de tokens determina a quantidade máxima de saída de texto de um comando. Um token tem cerca de quatro caracteres. O valor padrão é 1024.
O top-k muda a forma como o modelo seleciona tokens para saída. O valor 1 de top-k indica que o token selecionado é o mais provável entre todos no vocabulário do modelo (também chamado de decodificação gananciosa). Já o valor 3 significa que o próximo token é selecionado entre os três mais prováveis (usando a temperatura). O valor padrão do top-k é 40.
O top-p muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais ao menos provável até que a soma das probabilidades seja igual ao valor do top-p.
O número máximo de respostas é o número máximo de respostas do modelo geradas por comando.
Uma sequência de parada é uma série de caracteres (incluindo espaços) que interrompe a geração de resposta quando é encontrada pelo modelo.
A opção "Respostas com streaming" seleciona se as respostas devem ser impressas à medida que são geradas ou salvas e exibidas quando estiverem completas.
O limite do filtro de segurança ajusta a probabilidade de mostrar respostas que podem ser prejudiciais.

Depois de ter um comando que pareça gerar um teste razoável de acordo com os requisitos observados acima, podemos analisar esse teste usando um código personalizado. Mas não seria melhor pedir para o LLM gerar o teste em um formato estruturado que podemos carregar diretamente no nosso programa? O programa que vamos usar mais tarde neste laboratório para chamar seu gerador espera que os testes sejam expressos em JSON, um formato multilíngue popular para representar dados estruturados.

Os quizzes neste laboratório são expressos como uma matriz de objetos, em que cada objeto contém uma pergunta, uma matriz de possíveis respostas para essa pergunta e uma resposta correta. Confira a codificação JSON para os testes deste laboratório:

[
    {
        "question": "Who was the first person to walk on the moon?",
          "responses": [
              "Neil Armstrong",
              "Buzz Aldrin",
              "Michael Collins",
              "Yuri Gagarin"
           ],
           "correct": "Neil Armstrong"
    },
    {
        "question": "What was the name of the war that took place between the British and the French in North America from 1754 to 1763??",
          "responses": [
              "The French and Indian War",
              "The Seven Years' War",
              "The War of the Austrian Succession",
              "The Great War"
           ],
           "correct": "The French and Indian War"
    },

    ...
]

Veja se é possível modificar o comando para gerar o teste no formato JSON necessário.

Especifique em palavras o formato exato que você está procurando (por exemplo, a frase em itálico acima).
Inclua no comando um exemplo do formato JSON desejado.

Depois que o comando gerar quizzes de acordo com a especificação desejada, clique no botão GET CODE no canto superior direito da página para conferir o código Python que pode ser usado para enviar o comando de forma programática a um LLM da Vertex AI. Se você quiser usar uma linguagem de programação diferente do Python, acesse https://cloud.google.com/vertex-ai/docs/samples?text=generative.

4. Criar um servidor da Web simples

Agora que você tem um comando funcional, vamos integrá-lo a um app maior. É claro que poderíamos incorporar o comando ao código-fonte do app maior, mas queremos que o gerador funcione como um microsserviço que oferece um serviço de geração de testes para outros apps. Para isso, vamos criar um servidor da Web simples e disponibilizá-lo publicamente. Vamos fazer isso nas etapas a seguir.

Clique no botão Open Editor na parte de cima do painel do Cloud Shell. Esta é a aparência dela:

Em seguida, você vai estar em um ambiente de desenvolvimento integrado semelhante ao Visual Studio Code, em que é possível criar projetos, editar código-fonte, executar programas etc.

Se a tela estiver muito apertada, expanda ou reduza a linha divisória entre o console e a janela de edição/terminal arrastando a barra horizontal entre essas duas regiões, destacada aqui:

Clique nos botões Open Editor e Open Terminal para alternar entre o editor e o terminal, respectivamente. Tente alternar entre esses dois ambientes agora.

Em seguida, crie uma pasta para armazenar seu trabalho neste laboratório. Para isso, clique no botão de adicionar pasta , digite quiz-generator e pressione "Enter". Todos os arquivos criados neste laboratório e todo o trabalho feito no Cloud Shell serão realizados nessa pasta.

Agora, crie um arquivo requirements.txt. Isso informa ao Python de quais bibliotecas seu app depende. Para este app da Web simples, você vai usar um módulo Python conhecido para criar servidores da Web chamado Flask,, a biblioteca de cliente google-cloud-aiplatform e um framework de servidor da Web chamado gunicorn. No painel de navegação de arquivos, clique com o botão direito do mouse na pasta quiz-generator e selecione o item de menu New file, assim:

Quando for solicitado o nome do novo arquivo, digite requirements.txt e pressione a tecla Enter. Verifique se o novo arquivo está na pasta do projeto quiz-generator.

Cole as linhas a seguir no novo arquivo para especificar que seu app depende do pacote flask do Python, do servidor da Web gunicorn e da biblioteca de cliente google-cloud-aiplatform, além das versões associadas de cada um.

flask==3.0.0
gunicorn==21.2.0
google-cloud-aiplatform==1.47.0

Não é necessário salvar explicitamente esse arquivo porque o Cloud Editor salva automaticamente as mudanças para você.

Usando a mesma técnica, crie outro arquivo chamado main.py. Esse será o arquivo de origem principal (e único) do seu app em Python. Verifique se o novo arquivo está na pasta quiz-generator.

Insira o seguinte código no arquivo:

from flask import Flask
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Volte ao terminal e mude para a pasta do projeto com este comando:

cd quiz-generator

Execute o comando a seguir para instalar as dependências do projeto:

pip3 install -r requirements.txt

Depois de instalar as dependências, você vai ver uma saída que termina assim:

Successfully installed flask-3.0.0

Agora inicie o app executando este comando no terminal:

flask --app main.py --debug run --port 8080

Nesse momento, seu app está sendo executado na máquina virtual dedicada à sua sessão do Cloud Shell. O Cloud Shell inclui um mecanismo de proxy que permite acessar servidores da Web (como o que você acabou de iniciar) em execução na sua máquina virtual de qualquer lugar da Internet global.

Clique no botão web preview e no item de menu Preview on Port 8080, assim:

Isso vai abrir uma guia do navegador da Web com o app em execução, que deve ter esta aparência:

5. Adicionar um método de geração com análise de parâmetros

Agora, vamos adicionar suporte para um novo método chamado generate. Para fazer isso, adicione uma instrução de importação para manipular a solicitação HTTP e modifique a rota principal para analisar essa solicitação e imprimir parâmetros, da seguinte maneira:

from flask import Flask
from flask import request                       #<-CHANGED
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])                #<-CHANGED
def generate():                                 #<-CHANGED
    params = request.args.to_dict()             #<-CHANGED
    html = f"<h1>Quiz Generator</h1>"           #<-CHANGED
    for param in params:                        #<-CHANGED
        html += f"<br>{param}={params[param]}"  #<-CHANGED
    return html                                 #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Agora recarregue a guia do navegador da Web para conferir os resultados. Desta vez, você vai ver o "Gerador de testes", além de um parâmetro de consulta adicionado automaticamente ao seu URL (authuser). Tente adicionar mais dois parâmetros anexando a string "`&param1=val1&param2=val2`" ao final do URL na barra de endereço do navegador, recarregue a página e você vai ver algo assim:

Agora que vimos como enviar e analisar parâmetros de consulta em um URL, vamos adicionar suporte aos parâmetros específicos que queremos enviar ao nosso gerador de testes, que são os seguintes:

topic: o assunto desejado do teste
num_q: o número de perguntas desejadas
diff: o nível de dificuldade desejado (fácil, intermediário, difícil)
lang: o idioma desejado para o teste.

from flask import Flask
from flask import request
import os

# Default quiz settings  #<-CHANGED
TOPIC = "History"        #<-CHANGED
NUM_Q = "5"              #<-CHANGED
DIFF = "intermediate"    #<-CHANGED
LANG = "English"         #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):  #<-CHANGED
    if name in args:             #<-CHANGED
        return args[name]        #<-CHANGED
    return default               #<-CHANGED

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()        #<-CHANGED
    topic = check(args, "topic", TOPIC)  #<-CHANGED
    num_q = check(args, "num_q", NUM_Q)  #<-CHANGED
    diff = check(args, "diff", DIFF)     #<-CHANGED
    lang = check(args, "lang", LANG)     #<-CHANGED
    html = f"""
        <h1>Quiz Generator</h1><br>
        {topic=}<br>
        {num_q=}<br>
        {diff=}<br>
        {lang=}"""                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Agora recarregue a guia do navegador da Web para conferir os resultados. Você vai ver uma página da Web parecida com esta:

Tente mudar o URL para definir valores para vários parâmetros. Por exemplo, tente usar o sufixo "?authuser=0&topic=Literature&num_q=10&diff=easy&lang=French" no final do URL na barra de endereço:

6. Adicionar e formatar o comando

Em seguida, vamos adicionar suporte aos parâmetros específicos que queremos enviar ao gerador de testes, que são os seguintes:

topic: o assunto desejado do teste
num_q: o número de perguntas desejadas
diff: o nível de dificuldade desejado (fácil, intermediário, difícil)
lang: o idioma desejado para o teste.

Copie o comando que você desenvolveu com o Vertex AI Studio em uma etapa anterior, mas mude os valores codificados para tema, número de perguntas e nível de dificuldade com estas strings:

{topic}
{num_q}
{diff}
{lang}

from flask import Flask
from flask import request
import os

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys:
"Question", "responses", and "correct".

"""  #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)  #<-CHANGED 
    html = f"<h1>Prompt:</h1><br><pre>{prompt}</pre>"                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Agora recarregue a guia do navegador da Web para conferir os resultados. Você vai ver uma página da Web parecida com esta:

Tente modificar o URL para alterar esses quatro parâmetros.

7. Adicionar a biblioteca de cliente da Vertex AI

Agora estamos prontos para usar a biblioteca de cliente Python da Vertex AI e gerar seu teste. Isso vai automatizar o comando interativo que você fez na etapa 3 e dar ao seu serviço de geração acesso programático aos recursos de LLM do Google. Atualize o arquivo main.py da seguinte forma:

Substitua "YOUR_PROJECT" pelo ID do seu projeto.

from flask import Flask
from flask import request
from flask import Response                                          #<-CHANGED
import os

import vertexai    
from vertexai.generative_models import GenerativeModel  #<-CHANGED

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"
MODEL = "gemini-1.0-pro"  #<-CHANGED

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys "question", "responses", and "correct".

"""

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# Initialize Vertex AI access.
vertexai.init(project="YOUR_PROJECT", location="us-central1")  #<-CHANGED
parameters = {                                                 #<-CHANGED
    "candidate_count": 1,                                      #<-CHANGED
    "max_output_tokens": 1024,                                 #<-CHANGED
    "temperature": 0.5,                                        #<-CHANGED
    "top_p": 0.8,                                              #<-CHANGED
    "top_k": 40,                                               #<-CHANGED
}                                                              #<-CHANGED
model = GenerativeModel(MODEL)             #<-CHANGED

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)
    response = model.generate_content(prompt, generation_config=parameters)  #<-CHANGED
    print(f"Response from Model: {response.text}")           #<-CHANGED
    html = f"{response.text}"                                #<-CHANGED
    return Response(html, mimetype="application/json")       #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Agora recarregue a guia do navegador da Web para conferir os resultados. Isso pode levar alguns segundos porque agora você está fazendo uma solicitação de LLM. Você vai ver uma página da Web parecida com esta:

Tente alterar o URL para pedir um tema, número de perguntas e nível de dificuldade diferentes.

E assim o microsserviço está concluído. Parabéns! Na próxima etapa, você vai aprender a implantar seu serviço na nuvem para que qualquer pessoa possa acessar de qualquer lugar.

8. Para a nuvem!

Agora que você criou seu próprio gerador de testes, é hora de compartilhar essa maravilha com o resto do mundo. Por isso, vamos implantá-lo na nuvem. Mas você quer fazer mais do que apenas compartilhar. Você quer garantir que ele:

executa de maneira confiável: você recebe tolerância a falhas automática caso um computador que esteja executando seu app falhe
escalona automaticamente: seu app acompanha grandes níveis de tráfego e reduz automaticamente a pegada quando não está em uso.
minimiza seus custos, já que não cobra pelos recursos que você não está usando. Você paga apenas pelos recursos consumidos ao responder ao tráfego.
está acessível por um nome de domínio personalizado: você tem acesso a uma solução com um clique para atribuir um nome de domínio personalizado ao seu serviço
oferece um excelente tempo de resposta. As inicializações a frio são razoavelmente responsivas, mas é possível ajustar isso especificando uma configuração de instância mínima.
compatível com criptografia de ponta a ponta usando a segurança da Web SSL/TLS padrão. Ao implantar um serviço, você recebe criptografia da Web padrão e os certificados necessários correspondentes sem custo financeiro e automática.

Ao implantar seu app no Google Cloud Run, você tem tudo isso e muito mais. O elemento básico para compartilhar seu app com o Cloud Run é um contêiner.

Os contêineres nos dão a capacidade de criar uma caixa modular em que um aplicativo pode ser executado com todas as dependências agrupadas. Como os contêineres podem ser usados em quase qualquer servidor virtual ou real, isso nos dá uma maneira de implantar seu aplicativo em qualquer lugar, desde o local até a nuvem, e até mesmo mover seu aplicativo de um provedor de serviços para outro.

Para saber mais sobre contêineres e como eles funcionam no Google Cloud Run, confira o codelab Dev to Prod em três etapas fáceis com o Cloud Run.

Implantar seu app no Cloud Run

O Cloud Run é um serviço regional. Isso significa que a infraestrutura que executa seus serviços do Cloud Run está localizada em uma região específica e é gerenciada pelo Google para estar disponível de maneira redundante em todas as zonas dessa região. Para simplificar, neste laboratório vamos usar a região codificada us-central1.

Vamos usar algo chamado buildpack para gerar automaticamente seu contêiner. Crie um arquivo chamado Procfile no Cloud Editor e insira esta linha de texto:

web: gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

Isso informa ao sistema de buildpack como executar o app no contêiner gerado automaticamente. Em seguida, execute o comando a seguir no terminal do Cloud Shell (no mesmo diretório quiz-generator) :

gcloud run deploy quiz-generator  \
    --source .                    \
    --region us-central1          \
    --allow-unauthenticated

Isso informa ao comando gcloud que você quer usar buildpacks para criar a imagem do contêiner com base nos arquivos de origem encontrados no diretório atual (dot em --source . é uma abreviação do diretório atual). Como o serviço cuida da imagem do contêiner implicitamente, não é necessário especificar uma imagem nesse comando gcloud.

Aguarde alguns instantes até a implantação terminar. Em caso de sucesso, o comando gcloud exibe o URL do novo serviço:

Building using Buildpacks and deploying container to Cloud Run service [quiz-generator] in project [YOUR_PROJECT] region [YOUR_REGION]
OK Building and deploying new service... Done.                                                                          
  OK Creating Container Repository...                                                                                   
  OK Uploading sources...                                                                                               
  OK Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds/0cf1383f-35db-412d
  -a973-557d5e2cd4a4?project=780573810218].                                                                             
  OK Creating Revision...                                                                                               
  OK Routing traffic...                                                                                                 
  OK Setting IAM Policy...                                                                                              
Done.                                                                                                                   
Service [quiz-generator] revision [quiz-generator-00001-xnr] has been deployed and is serving 100 percent of traffic.
Service URL: https://quiz-generator-co24gukjmq-uc.a.run.app

Também é possível recuperar o URL do serviço com este comando:

gcloud run services describe quiz-generator  \
  --region us-central1                       \
  --format "value(status.url)"

Algo assim vai aparecer:

https://quiz-generator-co24gukjmq-uc.a.run.app

Esse link é um URL dedicado, com segurança TLS, para seu serviço do Cloud Run. Esse link é permanente (desde que você não desative o serviço) e pode ser usado em qualquer lugar na Internet. Ele não usa o mecanismo de proxy do Cloud Shell mencionado anteriormente, que dependia de uma máquina virtual temporária.

Clique no Service URL destacado para abrir uma guia do navegador da Web com o app em execução. Verifique se o resultado é o mesmo que você viu no ambiente de desenvolvimento. Verifique também se é possível ajustar o teste gerado fornecendo parâmetros no final do URL.

Parabéns! Agora seu app está sendo executado na nuvem do Google. Sem precisar pensar nisso, seu app fica disponível publicamente, com criptografia TLS (HTTPS) e escalonamento automático para níveis incríveis de tráfego.

9. Reunindo todas as peças

Nesta etapa final, vamos executar o gerador de testes como parte do app quizaic. Acesse o URL do quizaic, faça login na sua Conta do Google e navegue até a guia Create Quiz. Selecione o tipo de gerador Custom, cole o URL do Cloud Run no campo correspondente, preencha os outros campos obrigatórios e envie o formulário.

Em alguns instantes, você terá um novo teste (consulte "Meu novo teste" na imagem abaixo) com uma miniatura gerada por IA, que pode ser editada, reproduzida, clonada ou excluída usando os botões correspondentes. Esse novo teste foi criado usando o serviço da Web que você acabou de implantar com base no seu comando com modelo.

10. Como fazer a limpeza

O Cloud Run não gera custos quando o serviço não está em uso, mas você ainda vai receber cobranças pelo armazenamento da imagem de contêiner que você criou.

Para evitar cobranças, exclua seu projeto do GCP para interromper o faturamento de todos os recursos usados nesse projeto ou exclua sua imagem de contêiner usando este comando:

gcloud config set artifacts/repository cloud-run-source-deploy
gcloud config set artifacts/location us-central1
gcloud artifacts docker images list

# Note image tag for resulting list

gcloud artifacts docker images delete <IMAGE-TAG>

Para excluir o serviço do Cloud Run, use este comando:

gcloud run services delete quiz-generator --region us-central1 --quiet

11. Você conseguiu!

Parabéns! Você criou um comando de LLM e implantou um microsserviço do Cloud Run usando esse comando. Agora você pode programar em linguagem natural e compartilhar suas criações com o mundo!

Quero deixar uma pergunta importante:

Depois que o app começou a funcionar no ambiente de desenvolvimento, quantas linhas de código você precisou modificar para implantá-lo na nuvem, com todos os atributos de nível de produção oferecidos pelo Cloud Run?

A resposta, é claro, é zero. :)

Outros codelabs para conferir...

Documentos de referência…

12. Call-to-action

Se você gostou deste codelab e quer passar mais tempo praticando com o Google Cloud, participe do Google Cloud Innovators hoje mesmo!

O Google Cloud Innovators é sem custo financeiro e inclui:

Discussões ao vivo, AMAs e sessões de roteiro para saber as últimas novidades direto dos Googlers
as últimas notícias do Google Cloud direto na sua caixa de entrada
Selo digital e plano de fundo de videoconferência
500 créditos de laboratórios e aprendizado no Skills Boost

Clique aqui para se inscrever.

Criar um gerador de testes com a IA generativa e o Cloud Run Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

1. Introdução

O que você vai fazer…

O que você vai aprender…

O que é necessário…

2. Configuração

Configuração de ambiente autoguiada

Inicie o Cloud Shell

Ativar o Cloud Shell

Ativar algumas APIs

3. Comandos: programação em linguagem natural

4. Criar um servidor da Web simples

5. Adicionar um método de geração com análise de parâmetros

6. Adicionar e formatar o comando

7. Adicionar a biblioteca de cliente da Vertex AI

8. Para a nuvem!

Implantar seu app no Cloud Run

9. Reunindo todas as peças

10. Como fazer a limpeza

11. Você conseguiu!

Outros codelabs para conferir...

Documentos de referência…

12. Call-to-action

Criar um gerador de testes com a IA generativa e o Cloud Run