1. Introdução
Neste laboratório, você criará um serviço da Web para gerar testes de conhecimentos gerais e integrá-los a um app divertido e funcional. Você usará uma linguagem de programação diferente da que usava antes: o inglês!
O que você vai fazer…
- Você vai elaborar um comando que gere um teste de curiosidades de acordo com um conjunto de critérios.
- Você criará um app da Web simples e verificará se ele é executado conforme o esperado no seu 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ê 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 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 você estiver iniciando o Cloud Shell pela primeira vez, verá uma tela intermediária com a descrição dele. Se aparecer uma tela intermediária, clique em Continuar.
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual tem 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. Grande parte do trabalho neste codelab, se não todo, pode ser feito em um navegador.
Depois de se conectar ao Cloud Shell, você verá sua autenticação e o projeto estará 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 seguinte comando no Cloud Shell para confirmar que 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 saber onde e por que esses serviços são necessários. Por enquanto, 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 (linguagem). Você 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ê considere eficaz para gerar um teste de conhecimentos gerais, de acordo com os seguintes requisitos:
- Tópico: história mundial
- Número de perguntas: 5
- Nível de dificuldade: intermediário
- Idioma: inglês
Clique no botão "Enviar" para conferir o resultado.
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:
- A região é onde sua solicitação de geração deve 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 é 1.024.
- O top-k muda a forma como o modelo seleciona tokens para saída. Um top-k de "1" indica que o token selecionado é o mais provável entre todos no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto 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 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.
- O streaming de respostas seleciona se as respostas serão impressas à medida que forem geradas ou salvas e serão exibidas após a conclusão.
- O limite do filtro de segurança ajusta a probabilidade de você receber respostas possivelmente prejudiciais.
Quando você tem um comando que parece gerar um teste razoável de acordo com os requisitos mencionados acima, podemos analisar esse teste usando código personalizado, mas não seria melhor fazer com que o LLM gere o teste em um formato estruturado que possa ser carregado diretamente no nosso programa? O programa que usaremos mais adiante neste laboratório para chamar seu gerador espera que os testes sejam expressos em JSON, que é um formato conhecido em várias linguagens 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 respostas possíveis para a 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"
},
...
]
Tente modificar o comando para gerar o teste no formato JSON exigido.
- 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 testes de acordo com a especificação que você quer, 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 programaticamente o comando a um LLM da Vertex AI. Se você tiver interesse em usar uma linguagem de programação que não seja Python, confira https://cloud.google.com/vertex-ai/docs/samples?text=generative.
4. Crie um servidor da Web simples
Agora que você tem um comando funcional, queremos integrá-lo a um app maior. É claro que podemos incorporar o comando ao código-fonte do app maior, mas queremos que seu gerador funcione como um microsserviço que fornece 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. Faremos isso nas etapas a seguir.
Para começar, clique no botão Open Editor na parte superior do painel do Cloud Shell. Esta é a aparência dela:
Em seguida, você estará em um ambiente de desenvolvimento integrado semelhante ao Visual Studio Code, onde poderá criar projetos, editar o código-fonte, executar programas etc.
Se a tela estiver muito apertada, expanda ou diminua a linha divisória entre o console e a janela de edição/terminal arrastando a barra horizontal entre essas duas regiões, destacadas 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 o trabalho deste laboratório. Para isso, clique no botão de adição de 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 esse 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, desta forma:
Quando o nome do novo arquivo for solicitado, 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 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 explicitamente este arquivo, porque o Cloud Editor salva as mudanças automaticamente.
Usando a mesma técnica, crie outro arquivo com o nome main.py. Esse será o principal (e único) arquivo de origem Python do seu aplicativo. Novamente, 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 seguinte comando para instalar as dependências do projeto:
pip3 install -r requirements.txt
Depois de instalar as dependências, você 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
Neste ponto, 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, em seguida, no item de menu Preview on Port 8080, desta forma:
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 "Gerar" com análise de parâmetros
Agora, queremos adicionar suporte ao campo de um novo método com o nome generate. Para fazer 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)
Atualize a guia do navegador da Web atual para conferir os resultados. Desta vez, você verá o "Gerador de teste", junto com um parâmetro de consulta adicionado automaticamente ao URL (authuser). Adicione mais dois parâmetros anexando a string "`¶m1=val1¶m2=val2`" ao final do URL na barra de endereço do navegador, atualize a página e você verá algo parecido com isto:
Agora que vimos como enviar e analisar parâmetros de consulta em um URL, é hora de adicionar suporte para os parâmetros específicos que queremos enviar ao nosso 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)
Atualize a guia do navegador da Web atual para conferir os resultados. Você verá algo parecido com esta página da Web:
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 seu comando
Em seguida, vamos adicionar suporte para os parâmetros específicos que vamos enviar ao nosso 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.
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)
Atualize a guia do navegador da Web atual para conferir os resultados. Você verá algo parecido com esta página da Web:
Tente modificar o URL para alterar esses quatro parâmetros.
7. Adicionar a biblioteca de cliente da Vertex AI
Agora já podemos usar a biblioteca de cliente da Vertex AI para Python para gerar seu teste. Isso vai automatizar os comandos interativos que você fez na etapa 3 e conceder ao seu 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)
Atualize a guia do navegador da Web atual para conferir os resultados. Isso pode levar vários segundos, porque agora você está fazendo uma solicitação de LLM. Você verá algo parecido com esta página da Web:
Altere o URL para solicitar outro tema, número de perguntas e nível de dificuldade do teste.
Com isso, o microsserviço foi concluído. 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ê já criou seu próprio gerador de testes, é hora de compartilhar essas coisas incríveis com o mundo todo, então é hora de implantá-lo na nuvem. Mas você realmente quer fazer mais do que apenas compartilhar. Você quer garantir que:
- é executado de maneira confiável. Você tem tolerância automática a falhas caso um computador que executa seu aplicativo falhe
- escalona automaticamente - seu aplicativo acompanhará os grandes níveis de tráfego e reduzirá automaticamente sua pegada quando não for usado
- minimiza seus custos, não cobrando por recursos que você não usa - você é cobrado apenas pelos recursos consumidos ao responder ao tráfego
- pode ser acessado por meio de 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 segurança da Web SSL/TLS padrão. Ao implantar um serviço, você recebe a criptografia padrão da Web e os certificados necessários correspondentes, sem custo financeiro e automática
Ao implantar seu app no Google Cloud Run, você tem acesso a 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 Dev to Prod em três etapas fáceis com o Cloud Run.
Implante seu app no Cloud Run
O Cloud Run é um serviço regional, ou seja, 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 buildpack como executar o 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 buildpacks para criar sua imagem de contêiner, com base nos arquivos de origem que encontrar no diretório atual. O 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 neste 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)"
O resultado será semelhante a este:
https://quiz-generator-co24gukjmq-uc.a.run.app
Este link é um URL dedicado, com segurança TLS, para seu serviço do Cloud Run. Esse link é permanente (desde que você não desative seu 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 para o app em execução. Verifique se o resultado é o mesmo que você viu no ambiente de desenvolvimento. Verifique também se você consegue ajustar o teste gerado fornecendo parâmetros no final do URL.
Parabéns! Seu app está em execução na nuvem do Google. Sem se preocupar, seu app está disponível publicamente, com criptografia TLS (HTTPS) e escalonamento automático para níveis de tráfego surpreendentes.
9. Como juntar todas as peças
Nesta etapa final, estamos prontos para executar o gerador de testes como parte do app Quizaic. Acesse o URL do questionário, 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ê terá um novo teste (confira "Meu novo teste" na imagem abaixo) com uma miniatura gerada por IA, que você pode editar, abrir, clonar ou excluir usando os botões correspondentes. Este 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.
É 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. Você conseguiu!
Parabéns! Você criou um comando 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 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 é zero. :)
Outros codelabs para conferir...
- Dev to Prod em três etapas fáceis com o Cloud Run
- App resumidor 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 une os modelos text-bison em PaLM
- 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 provavelmente vai 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, AMAs e sessões de roteiro ao vivo para ficar por dentro das novidades diretamente dos Googlers
- Receba as últimas notícias sobre o Google Cloud na sua caixa de entrada
- Selo digital e plano de fundo de videoconferência
- 500 créditos de laboratórios e aprendizado no Google Cloud Ensina
Clique aqui para se inscrever.