1. Introdução
Neste laboratório, você vai criar um serviço da Web para gerar testes de perguntas 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 uma instrução que gera um teste de perguntas 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ê adicionará lógica gradualmente ao app da Web para transformá-lo em um servidor de API que gera testes de acordo com um conjunto de parâmetros de entrada.
- Você vai descobrir 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 geração de testes implantado e poderá executar testes ao vivo com base nos resultados.
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 ao seu app da Web.
- Como implantar o app na nuvem para que qualquer pessoa possa testar sua nova criação.
- Como integrar seu gerador de testes em 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. Mesmo usando Python, não é preciso conhecer programação para entender o que está acontecendo, porque vamos explicar todo o código exibido.
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ê iniciar o Cloud Shell, uma tela intermediária vai aparecer com uma descrição dele. Se esse for o caso, 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 e é executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Grande parte do trabalho neste codelab, se não todo, pode ser feito em um navegador.
Depois de se conectar ao Cloud Shell, você vai notar que sua conta já está autenticada e que o projeto está configurado com seu ID do 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. Comando: 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 (Idioma). Você vai ver uma página como esta:
Em Generate Text, clique no botão Text Prompt. Na próxima caixa de diálogo, insira uma instrução que você acha que pode ser eficaz para gerar um teste de perguntas e respostas 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 conferir a saída.
Como mostrado na captura de tela a seguir, o painel à direita permite selecionar qual modelo você quer usar e ajustar algumas configurações:
As seguintes configurações estão disponíveis:
- Região é onde a solicitação de geração precisa ser executada.
- O modelo seleciona qual modelo de linguagem grande você quer usar. Neste 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 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.
- O streaming de respostas seleciona se as respostas devem ser impressas à medida que são geradas ou salvas e são exibidas após a conclusão.
- O limite do filtro de segurança ajusta a probabilidade de você receber respostas possivelmente prejudiciais.
Depois de ter uma instrução que parece gerar um teste razoável de acordo com os requisitos acima, podemos analisar esse teste usando um código personalizado, mas não seria melhor se o LLM gerasse o teste em um formato estruturado que podemos carregar diretamente no nosso programa? O programa que vamos usar mais adiante neste laboratório para chamar seu gerador espera que os testes sejam expressos em JSON, um formato comum entre idiomas para representar dados estruturados.
Os testes 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 a essa pergunta e uma resposta correta. Esta é 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"
},
...
]
Verifique se é possível modificar o comando para que ele gere 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 de criar o comando que gera testes de acordo com a especificação desejada, clique no botão GET CODE no canto superior direito da página para ver 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 uma solicitação funcional, queremos integrá-la a um app maior. Claro, podemos incorporar sua solicitação ao código-fonte do app maior, mas queremos que seu gerador funcione como um microsserviço que ofereça um serviço de geração de testes para outros apps. Para que isso aconteça, precisamos criar um servidor da Web simples e disponibilizá-lo publicamente. Vamos fazer isso nas próximas etapas.
Para começar, clique no botão Open Editor na parte superior do painel do Cloud Shell. Esta é a aparência dela:
Você vai se encontrar em um ambiente de IDE semelhante ao Visual Studio Code, em que é possível criar projetos, editar o código-fonte, executar programas etc.
Se a tela estiver muito apertada, você pode expandir ou encolher a linha divisória entre o console e a janela de edição/terminal arrastando a barra horizontal entre essas duas regiões, conforme destacado aqui:
Para alternar entre o editor e o terminal, clique nos botões Open Editor e Open Terminal, respectivamente. Tente alternar entre esses dois ambientes agora.
Em seguida, crie uma pasta para armazenar seu trabalho para este laboratório clicando no botão de adicionar pasta 
, digite quiz-generator e pressione Enter. Todos os arquivos que você criar neste laboratório e todo o trabalho que você realizar no Cloud Shell serão realizados nessa pasta.
Agora, crie um arquivo requirements.txt. Isso informa ao Python de quais bibliotecas seu aplicativo 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, como este:
Quando for solicitado o nome do novo arquivo, digite requirements.txt e pressione a tecla Enter. Confira se o novo arquivo está na pasta do projeto quiz-generator.
Cole as linhas a seguir no novo arquivo para especificar que o aplicativo depende do pacote flask do Python, do servidor da Web gunicorn e da biblioteca de cliente google-cloud-aiplatform, com as 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 esse arquivo explicitamente, porque o Cloud Editor salva as alterações automaticamente.
Usando a mesma técnica, crie outro arquivo chamado main.py. Esse será o arquivo de origem principal (e único) do Python do seu app. Verifique se o novo arquivo está na pasta quiz-generator.
Insira o código a seguir nesse 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 acesse 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
Execute este comando no terminal para iniciar o app:
flask --app main.py --debug run --port 8080
Nesse ponto, o 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.
Clique no botão web preview e no item de menu Preview on Port 8080, como mostrado abaixo:
Isso vai abrir uma guia do navegador da Web para o app em execução, que terá esta aparência:
5. Adicionar um método de geração com análise de parâmetros
Agora queremos adicionar suporte para um novo método chamado generate. Para isso, adicione uma instrução de importação para manipular a solicitação HTTP e modificar a rota principal para analisar essa solicitação e exibir 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, atualize a guia do navegador da Web para conferir os resultados. Dessa vez, você vai encontrar o "Quiz Generator" e um parâmetro de consulta adicionado automaticamente ao seu URL (authuser). Adicione dois parâmetros anexando a string "`¶m1=val1¶m2=val2`" ao final do URL na barra de endereço do navegador, recarregando a página e você vai encontrar algo como isto:
Agora que você já sabe como enviar e analisar parâmetros de consulta em um URL, 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 testenum_q: o número de perguntas desejadasdiff: o nível de dificuldade desejado (fácil, intermediário, difícil)lang: o idioma desejado do 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, atualize a guia do navegador da Web para conferir os resultados. Você verá uma página da Web semelhante a esta:
Tente alterar 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 tema do teste desejadonum_q: o número de perguntas desejadasdiff: o nível de dificuldade desejado (fácil, intermediário, difícil)lang: o idioma do teste desejado
Copie o comando que você desenvolveu com o Vertex Generative AI Studio em uma etapa anterior, mas mude os valores codificados para o tema, o número de perguntas e o 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, atualize a guia do navegador da Web para conferir os resultados. Você verá uma página da Web semelhante a esta:
Tente modificar o URL para alterar esses quatro parâmetros.
7. Adicionar a biblioteca de cliente da Vertex AI
Agora está tudo pronto para usar a biblioteca de cliente Python da Vertex AI para gerar o teste. Isso vai automatizar a solicitação interativa que você fez na etapa 3 e dar ao serviço de gerador acesso programático aos recursos de LLM do Google. Atualize o arquivo main.py da seguinte maneira:
Substitua "YOUR_PROJECT" pelo ID do projeto real.
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, atualize a guia do navegador da Web para conferir os resultados. Isso pode levar alguns segundos, porque você está fazendo uma solicitação de LLM. Você verá uma página da Web semelhante a esta:
Tente alterar o URL para solicitar um tema, número de perguntas e nível de dificuldade diferentes.
E com isso, seu microsserviço está pronto. Parabéns! Na próxima etapa, você vai aprender a implantar seu serviço na nuvem para que qualquer pessoa possa acessá-lo de qualquer lugar.
8. Para a nuvem!
Agora que você criou seu próprio gerador de testes, vai querer compartilhar essa maravilha com o mundo. É hora de implantar na nuvem. Mas você realmente quer fazer mais do que apenas compartilhar. Você quer ter certeza de que:
- executa de forma confiável: você tem tolerância a falhas automáticas caso um computador que executa seu app falhe
- é escalonado automaticamente: seu app acompanha grandes níveis de tráfego e reduz automaticamente a pegada quando não está em uso.
- minimiza seus custos, não cobrando por recursos que você não está usando. Você só paga pelos recursos consumidos ao responder ao tráfego
- é acessível por um nome de domínio personalizado: você tem acesso a uma solução de um clique para atribuir um nome de domínio personalizado ao seu serviço
- oferece excelente tempo de resposta: inicializações a frio são razoavelmente responsivas, mas você pode ajustar isso especificando uma configuração de instância mínima.
- oferece suporte à criptografia de ponta a ponta usando a segurança da Web SSL/TLS padrão. Quando você implanta um serviço, recebe a 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 permitem criar uma caixa modular para executar um aplicativo com todas as dependências agrupadas. Como os contêineres podem ser usados em praticamente qualquer servidor virtual ou real, isso nos oferece uma maneira de implantar seu aplicativo onde você quiser, do local para a nuvem e até mesmo movê-lo 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 De desenvolvimento à produção em três etapas simples com o Cloud Run.
Implante seu app no Cloud Run
O Cloud Run é um serviço regional, o que 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 seu contêiner automaticamente. 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 do buildpack como executar seu app no contêiner gerado automaticamente. Em seguida, execute o seguinte comando 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 que ele use os buildpacks para criar a imagem do contêiner com base nos arquivos de origem encontrados no diretório atual (o dot em --source . é uma abreviação para o diretório atual). Como o serviço cuida da imagem do contêiner de forma implícita, não é necessário especificar uma imagem neste comando gcloud.
Aguarde alguns instantes até a implantação terminar. Em caso de sucesso, o comando gcloud mostra 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)"
Isso vai mostrar algo como:
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 da 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 no app em execução. Verifique se o resultado é o mesmo que você encontrou no ambiente de desenvolvimento. Verifique também se é possível ajustar o teste gerado fornecendo parâmetros no final do URL.
Parabéns! Seu app está em execução 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. Como juntar 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 de URL, preencha os outros campos obrigatórios e envie o formulário.
Em alguns instantes, você vai ter um novo teste (veja "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. Este novo teste foi criado usando o serviço da Web que você acabou de implantar com base no comando de 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.
É possível excluir seu projeto do GCP para evitar cobranças, o que interromperá o faturamento de todos os recursos usados nele, ou simplesmente excluir 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. Parabéns!
Parabéns! Você criou uma solicitação de LLM e implantou um microsserviço do Cloud Run usando essa solicitação. Agora você pode programar em linguagem natural e compartilhar suas criações com o mundo!
Quero deixar uma pergunta importante para você:
Depois de colocar o app para funcionar no seu ambiente de desenvolvedor, 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:
- De desenvolvimento à produção em três etapas simples com o Cloud Run
- App de resumo de texto com a Vertex AI e o Svelte Kit
- App de chat com a API PaLM no Cloud Run
- Função do Cloud que envolve os modelos PaLM Text Bison
- Dados para IA generativa com o Spanner e a API Vertex AI Imagen
Documentos de referência…
12. Call-to-action
Se você gostou deste codelab e pretende passar mais tempo com o Google Cloud, participe do Google Cloud Innovators hoje mesmo.
O Google Cloud Innovators é sem custo financeiro e inclui:
- Discussões, AMAs e sessões de planejamento ao vivo para aprender as novidades diretamente com os Googlers
- as últimas notícias do Google Cloud na sua caixa de entrada
- Selo digital e plano de fundo da videoconferência
- 500 créditos de laboratórios e aprendizado no Skills Boost
Clique aqui para se inscrever.