1. Visão geral
No primeiro codelab, você vai armazenar fotos em um bucket. Isso vai gerar um evento de criação de arquivo que será processado por um serviço implantado no Cloud Run. O serviço fará uma chamada para a API Vision para analisar imagens e salvar os resultados em um datastore.
O que você vai aprender
- Cloud Storage
- Cloud Run
- API Cloud Vision
- Cloud Firestore
2. Configuração e requisitos
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
Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.
No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:
O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:
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, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.
3. Ativar APIs
Neste laboratório, você vai usar o Cloud Functions e a API Vision, mas primeiro eles precisam ser ativados no console do Cloud ou com gcloud.
Para ativar a API Vision no Console do Cloud, pesquise Cloud Vision API na barra de pesquisa:
Você vai acessar a página da API Cloud Vision:
Clique no botão ENABLE.
Como alternativa, você também pode ativar o Cloud Shell usando a ferramenta de linha de comando gcloud.
No Cloud Shell, execute este comando:
gcloud services enable vision.googleapis.com
A operação será concluída com sucesso:
Operation "operations/acf.12dba18b-106f-4fd2-942d-fea80ecc5c1c" finished successfully.
Ative também o Cloud Run e o Cloud Build:
gcloud services enable cloudbuild.googleapis.com \ run.googleapis.com
4. Criar o bucket (console)
Crie um bucket de armazenamento para as fotos. É possível fazer isso no console do Google Cloud Platform ( console.cloud.google.com) ou com a ferramenta de linha de comando gsutil no Cloud Shell ou no seu ambiente de desenvolvimento local.
Acesse "Storage"
No menu "hambúrguer" (☰), navegue até a página Storage.
Nomeie seu bucket
Clique no botão CREATE BUCKET.
Clique em CONTINUE.
Escolher local
Crie um bucket multirregional na região de sua escolha (aqui Europe).
Clique em CONTINUE.
Escolher a classe de armazenamento padrão
Escolha a classe de armazenamento Standard para seus dados.
Clique em CONTINUE.
Definir controle de acesso
Como você vai trabalhar com imagens acessíveis ao público, é importante que todas as fotos armazenadas nesse bucket tenham o mesmo controle de acesso uniforme.
Escolha a opção de controle de acesso Uniform.
Clique em CONTINUE.
Definir proteção/criptografia
Mantenha o padrão (Google-managed key)), já que você não vai usar suas próprias chaves de criptografia.
Clique em CREATE para finalizar a criação do bucket.
Adicionar allUsers como leitor de armazenamento
Acesse a guia Permissions:
Adicione um membro allUsers ao bucket com o papel Storage > Storage Object Viewer da seguinte maneira:
Clique em SAVE.
5. Criar o bucket (gsutil)
Também é possível usar a ferramenta de linha de comando gsutil no Cloud Shell para criar buckets.
No Cloud Shell, defina uma variável para o nome exclusivo do bucket. O Cloud Shell já tem GOOGLE_CLOUD_PROJECT definido como o ID exclusivo do seu projeto. Você pode anexar isso ao nome do bucket.
Exemplo:
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
Crie uma zona padrão multirregional na Europa:
gsutil mb -l EU gs://${BUCKET_PICTURES}
Verifique se o acesso uniforme no nível do bucket está ativado:
gsutil uniformbucketlevelaccess set on gs://${BUCKET_PICTURES}
Torne o bucket público:
gsutil iam ch allUsers:objectViewer gs://${BUCKET_PICTURES}
Se você acessar a seção Cloud Storage do console, vai encontrar um bucket uploaded-pictures público:
Teste se é possível fazer upload de fotos para o bucket e se elas estão disponíveis publicamente, conforme explicado na etapa anterior.
6. Testar o acesso público ao bucket
Voltando ao navegador de armazenamento, você vai ver seu bucket na lista, com acesso "Público" (incluindo um sinal de alerta lembrando que qualquer pessoa tem acesso ao conteúdo desse bucket).
Seu bucket está pronto para receber fotos.
Se você clicar no nome do bucket, vai ver os detalhes dele.
Lá, você pode clicar no botão Upload files para testar se é possível adicionar uma imagem ao bucket. Uma janela pop-up vai pedir para você selecionar um arquivo. Depois de selecionado, ele será enviado por upload para seu bucket, e você verá novamente o acesso public atribuído automaticamente a esse novo arquivo.
Ao lado do marcador de acesso Public, você também vai encontrar um pequeno ícone de link. Ao clicar nele, seu navegador vai navegar até o URL público da imagem, que terá o seguinte formato:
https://storage.googleapis.com/BUCKET_NAME/PICTURE_FILE.png
Em que BUCKET_NAME é o nome globalmente exclusivo escolhido para o bucket e o nome do arquivo da imagem.
Ao clicar na caixa de seleção ao lado do nome da imagem, o botão DELETE será ativado, e você poderá excluir a primeira imagem.
7. Preparar o banco de dados
Você vai armazenar informações sobre a imagem fornecida pela API Vision no banco de dados Cloud Firestore, um banco de dados de documentos NoSQL rápido, totalmente gerenciado, sem servidor e nativo da nuvem. Prepare seu banco de dados acessando a seção Firestore do Console do Cloud:
Há duas opções: Native mode ou Datastore mode. Use o modo nativo, que oferece recursos extras, como suporte off-line e sincronização em tempo real.
Clique em SELECT NATIVE MODE.
Escolha uma multirregião (aqui na Europa, mas o ideal é pelo menos a mesma região da função e do bucket de armazenamento).
Clique no botão CREATE DATABASE.
Depois que o banco de dados for criado, você verá o seguinte:
Crie uma coleção clicando no botão + START COLLECTION.
Nomeie a coleção pictures.
Não é necessário criar um documento. Você vai adicioná-los de forma programática à medida que novas imagens forem armazenadas no Cloud Storage e analisadas pela API Vision.
Clique em Save.
O Firestore cria um primeiro documento padrão na coleção recém-criada. Você pode excluir esse documento com segurança, porque ele não contém informações úteis:
Os documentos que serão criados de forma programática na nossa coleção vão conter quatro campos:
- name (string): o nome do arquivo da imagem enviada, que também é a chave do documento.
- labels (matriz de strings): os rótulos dos itens reconhecidos pela API Vision.
- color (string): o código hexadecimal da cor dominante (por exemplo, #ab12ef)
- created (data): o carimbo de data/hora de quando os metadados da imagem foram armazenados.
- thumbnail (booleano): um campo opcional que estará presente e será verdadeiro se uma imagem em miniatura tiver sido gerada para essa foto.
Como vamos pesquisar no Firestore para encontrar fotos com miniaturas disponíveis e classificar pela data de criação, precisamos criar um índice de pesquisa.
É possível criar o índice com o seguinte comando no Cloud Shell:
gcloud firestore indexes composite create \
--collection-group=pictures \
--field-config field-path=thumbnail,order=descending \
--field-config field-path=created,order=descending
Ou você pode fazer isso no console do Cloud. Clique em Indexes na coluna de navegação à esquerda e crie um índice composto, conforme mostrado abaixo:
Clique em Create. A criação do índice pode levar alguns minutos.
8. Clonar o código
Clone o código, caso ainda não tenha feito isso no codelab anterior:
git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop
Em seguida, acesse o diretório que contém o serviço para começar a criar o laboratório:
cd serverless-photosharing-workshop/services/image-analysis/java
Você terá o seguinte layout de arquivo para o serviço:
9. Conhecer o código do serviço
Primeiro, veja como as bibliotecas de cliente Java são ativadas no pom.xml usando uma BOM:
Primeiro, abra o arquivo pom.xml, que lista as dependências do nosso app Java. O foco está no uso das APIs Vision, Cloud Storage e Firestore.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.0-M3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>services</groupId>
<artifactId>image-analysis</artifactId>
<version>0.0.1</version>
<name>image-analysis</name>
<description>Spring App for Image Analysis</description>
<properties>
<java.version>17</java.version>
<maven.compiler.target>17</maven.compiler.target>
<maven.compiler.source>17</maven.compiler.source>
<spring-cloud.version>2023.0.0-M2</spring-cloud.version>
<testcontainers.version>1.19.1</testcontainers.version>
</properties>
...
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>libraries-bom</artifactId>
<version>26.24.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
—
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-function-web</artifactId>
</dependency>
<dependency>
<groupId>com.google.cloud.functions</groupId>
<artifactId>functions-framework-api</artifactId>
<version>1.1.0</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-firestore</artifactId>
</dependency>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-vision</artifactId>
</dependency>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-storage</artifactId>
</dependency>
A funcionalidade é implementada na classe EventController. Toda vez que uma nova imagem é enviada para o bucket, o serviço recebe uma notificação para processar:
@RestController
public class EventController {
private static final Logger logger = Logger.getLogger(EventController.class.getName());
private static final List<String> requiredFields = Arrays.asList("ce-id", "ce-source", "ce-type", "ce-specversion");
@RequestMapping(value = "/", method = RequestMethod.POST)
public ResponseEntity<String> receiveMessage(
@RequestBody Map<String, Object> body, @RequestHeader Map<String, String> headers) throws IOException, InterruptedException, ExecutionException {
...
}
O código vai validar os cabeçalhos Cloud Events:
System.out.println("Header elements");
for (String field : requiredFields) {
if (headers.get(field) == null) {
String msg = String.format("Missing expected header: %s.", field);
System.out.println(msg);
return new ResponseEntity<String>(msg, HttpStatus.BAD_REQUEST);
} else {
System.out.println(field + " : " + headers.get(field));
}
}
System.out.println("Body elements");
for (String bodyField : body.keySet()) {
System.out.println(bodyField + " : " + body.get(bodyField));
}
if (headers.get("ce-subject") == null) {
String msg = "Missing expected header: ce-subject.";
System.out.println(msg);
return new ResponseEntity<String>(msg, HttpStatus.BAD_REQUEST);
}
Agora, uma solicitação pode ser criada, e o código vai preparar uma dessas solicitações para ser enviada ao Vision API:
try (ImageAnnotatorClient vision = ImageAnnotatorClient.create()) {
List<AnnotateImageRequest> requests = new ArrayList<>();
ImageSource imageSource = ImageSource.newBuilder()
.setGcsImageUri("gs://" + bucketName + "/" + fileName)
.build();
Image image = Image.newBuilder()
.setSource(imageSource)
.build();
Feature featureLabel = Feature.newBuilder()
.setType(Type.LABEL_DETECTION)
.build();
Feature featureImageProps = Feature.newBuilder()
.setType(Type.IMAGE_PROPERTIES)
.build();
Feature featureSafeSearch = Feature.newBuilder()
.setType(Type.SAFE_SEARCH_DETECTION)
.build();
AnnotateImageRequest request = AnnotateImageRequest.newBuilder()
.addFeatures(featureLabel)
.addFeatures(featureImageProps)
.addFeatures(featureSafeSearch)
.setImage(image)
.build();
requests.add(request);
Estamos pedindo três recursos principais da API Vision:
- Detecção de rótulos: para entender o que há nas fotos
- Propriedades da imagem: para fornecer atributos interessantes da imagem (a cor dominante)
- Pesquisa segura: para saber se a imagem é segura para exibição (não deve conter conteúdo adulto, médico, sugestivo ou violento)
Neste ponto, podemos fazer a chamada para a API Vision:
...
logger.info("Calling the Vision API...");
BatchAnnotateImagesResponse result = vision.batchAnnotateImages(requests);
List<AnnotateImageResponse> responses = result.getResponsesList();
...
Para referência, confira como é a resposta da API Vision:
{
"faceAnnotations": [],
"landmarkAnnotations": [],
"logoAnnotations": [],
"labelAnnotations": [
{
"locations": [],
"properties": [],
"mid": "/m/01yrx",
"locale": "",
"description": "Cat",
"score": 0.9959855675697327,
"confidence": 0,
"topicality": 0.9959855675697327,
"boundingPoly": null
},
✄ - - - ✄
],
"textAnnotations": [],
"localizedObjectAnnotations": [],
"safeSearchAnnotation": {
"adult": "VERY_UNLIKELY",
"spoof": "UNLIKELY",
"medical": "VERY_UNLIKELY",
"violence": "VERY_UNLIKELY",
"racy": "VERY_UNLIKELY",
"adultConfidence": 0,
"spoofConfidence": 0,
"medicalConfidence": 0,
"violenceConfidence": 0,
"racyConfidence": 0,
"nsfwConfidence": 0
},
"imagePropertiesAnnotation": {
"dominantColors": {
"colors": [
{
"color": {
"red": 203,
"green": 201,
"blue": 201,
"alpha": null
},
"score": 0.4175916016101837,
"pixelFraction": 0.44456374645233154
},
✄ - - - ✄
]
}
},
"error": null,
"cropHintsAnnotation": {
"cropHints": [
{
"boundingPoly": {
"vertices": [
{ "x": 0, "y": 118 },
{ "x": 1177, "y": 118 },
{ "x": 1177, "y": 783 },
{ "x": 0, "y": 783 }
],
"normalizedVertices": []
},
"confidence": 0.41695669293403625,
"importanceFraction": 1
}
]
},
"fullTextAnnotation": null,
"webDetection": null,
"productSearchResults": null,
"context": null
}
Se não houver um erro retornado, podemos continuar. Por isso, temos este bloco "if":
if (responses.size() == 0) {
logger.info("No response received from Vision API.");
return new ResponseEntity<String>(msg, HttpStatus.BAD_REQUEST);
}
AnnotateImageResponse response = responses.get(0);
if (response.hasError()) {
logger.info("Error: " + response.getError().getMessage());
return new ResponseEntity<String>(msg, HttpStatus.BAD_REQUEST);
}
Vamos receber os rótulos das coisas, categorias ou temas reconhecidos na imagem:
List<String> labels = response.getLabelAnnotationsList().stream()
.map(annotation -> annotation.getDescription())
.collect(Collectors.toList());
logger.info("Annotations found:");
for (String label: labels) {
logger.info("- " + label);
}
Queremos saber a cor dominante da imagem:
String mainColor = "#FFFFFF";
ImageProperties imgProps = response.getImagePropertiesAnnotation();
if (imgProps.hasDominantColors()) {
DominantColorsAnnotation colorsAnn = imgProps.getDominantColors();
ColorInfo colorInfo = colorsAnn.getColors(0);
mainColor = rgbHex(
colorInfo.getColor().getRed(),
colorInfo.getColor().getGreen(),
colorInfo.getColor().getBlue());
logger.info("Color: " + mainColor);
}
Vamos verificar se a imagem é segura para mostrar:
boolean isSafe = false;
if (response.hasSafeSearchAnnotation()) {
SafeSearchAnnotation safeSearch = response.getSafeSearchAnnotation();
isSafe = Stream.of(
safeSearch.getAdult(), safeSearch.getMedical(), safeSearch.getRacy(),
safeSearch.getSpoof(), safeSearch.getViolence())
.allMatch( likelihood ->
likelihood != Likelihood.LIKELY && likelihood != Likelihood.VERY_LIKELY
);
logger.info("Safe? " + isSafe);
}
Estamos verificando as características de conteúdo adulto, falsificação, médico, violência e conteúdo sugestivo para saber se elas não são prováveis ou muito prováveis.
Se o resultado da pesquisa segura for positivo, podemos armazenar metadados no Firestore:
// Saving result to Firestore
if (isSafe) {
ApiFuture<WriteResult> writeResult =
eventService.storeImage(fileName, labels,
mainColor);
logger.info("Picture metadata saved in Firestore at " +
writeResult.get().getUpdateTime());
}
...
public ApiFuture<WriteResult> storeImage(String fileName,
List<String> labels,
String mainColor) {
FirestoreOptions firestoreOptions = FirestoreOptions.getDefaultInstance();
Firestore pictureStore = firestoreOptions.getService();
DocumentReference doc = pictureStore.collection("pictures").document(fileName);
Map<String, Object> data = new HashMap<>();
data.put("labels", labels);
data.put("color", mainColor);
data.put("created", new Date());
return doc.set(data, SetOptions.merge());
}
10. Criar imagens de app com o GraalVM
Nesta etapa opcional, você vai criar um JIT based app image e um Native Java app image usando o GraalVM.
Para executar o build, verifique se você tem um JDK adequado e o criador de native-image instalado e configurado. Há várias opções disponíveis.
To start, faça o download da GraalVM 22.3.x Community Edition e siga as instruções na página de instalação da GraalVM.
Esse processo pode ser muito simplificado com a ajuda do SDKMAN!
Para instalar a distribuição do JDK adequada com SDKman, comece usando o comando de instalação:
sdk install java 17.0.8-graal
Instrua o SDKman a usar essa versão para builds JIT e AOT:
sdk use java 17.0.8-graal
No Cloudshell, para sua conveniência, é possível instalar o GraalVM e o utilitário native-image com estes comandos simples:
# download GraalVM wget https://download.oracle.com/graalvm/17/latest/graalvm-jdk-17_linux-x64_bin.tar.gz tar -xzf graalvm-jdk-17_linux-x64_bin.tar.gz ls -lart # configure Java 17 and GraalVM for Java 17 # note the name of the latest GraalVM version, as unpacked by the tar command echo Existing JVM: $JAVA_HOME cd graalvm-jdk-17.0.8+9.1 export JAVA_HOME=$PWD cd bin export PATH=$PWD:$PATH echo JAVA HOME: $JAVA_HOME echo PATH: $PATH cd ../.. # validate the version with java -version # observe Java(TM) SE Runtime Environment Oracle GraalVM 17.0.8+9.1 (build 17.0.8+9-LTS-jvmci-23.0-b14) Java HotSpot(TM) 64-Bit Server VM Oracle GraalVM 17.0.8+9.1 (build 17.0.8+9-LTS-jvmci-23.0-b14, mixed mode, sharing)
Primeiro, defina as variáveis de ambiente do projeto do GCP:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
Em seguida, acesse o diretório que contém o serviço para começar a criar o laboratório:
cd serverless-photosharing-workshop/services/image-analysis/java
Crie a imagem do aplicativo JIT:
./mvnw package
Observe o registro de build no terminal:
... [INFO] Results: [INFO] [INFO] Tests run: 6, Failures: 0, Errors: 0, Skipped: 0 [INFO] [INFO] [INFO] --- maven-jar-plugin:3.3.0:jar (default-jar) @ image-analysis --- [INFO] Building jar: /home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis-0.0.1.jar [INFO] [INFO] --- spring-boot-maven-plugin:3.2.0-M3:repackage (repackage) @ image-analysis --- [INFO] Replacing main artifact /home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis-0.0.1.jar with repackaged archive, adding nested dependencies in BOOT-INF/. [INFO] The original artifact has been renamed to /home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis-0.0.1.jar.original [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 15.335 s [INFO] Finished at: 2023-10-10T19:33:25Z [INFO] ------------------------------------------------------------------------
Crie a imagem nativa(usa AOT):
./mvnw native:compile -Pnative
Observe o registro do build no terminal, incluindo os registros do build de imagem nativa:
A compilação leva um pouco mais de tempo, dependendo da máquina em que você está testando.
...
[2/7] Performing analysis... [*********] (124.5s @ 4.53GB)
29,732 (93.19%) of 31,905 classes reachable
60,161 (70.30%) of 85,577 fields reachable
261,973 (67.29%) of 389,319 methods reachable
2,940 classes, 2,297 fields, and 97,421 methods registered for reflection
81 classes, 90 fields, and 62 methods registered for JNI access
4 native libraries: dl, pthread, rt, z
[3/7] Building universe... (11.7s @ 4.67GB)
[4/7] Parsing methods... [***] (6.1s @ 5.91GB)
[5/7] Inlining methods... [****] (4.5s @ 4.39GB)
[6/7] Compiling methods... [******] (35.3s @ 4.60GB)
[7/7] Creating image... (12.9s @ 4.61GB)
80.08MB (47.43%) for code area: 190,483 compilation units
73.81MB (43.72%) for image heap: 660,125 objects and 189 resources
14.95MB ( 8.86%) for other data
168.84MB in total
------------------------------------------------------------------------------------------------------------------------
Top 10 packages in code area: Top 10 object types in image heap:
2.66MB com.google.cloud.vision.v1p4beta1 18.51MB byte[] for code metadata
2.60MB com.google.cloud.vision.v1 9.27MB java.lang.Class
2.49MB com.google.protobuf 7.34MB byte[] for reflection metadata
2.40MB com.google.cloud.vision.v1p3beta1 6.35MB byte[] for java.lang.String
2.17MB com.google.storage.v2 5.72MB java.lang.String
2.12MB com.google.firestore.v1 4.46MB byte[] for embedded resources
1.64MB sun.security.ssl 4.30MB c.oracle.svm.core.reflect.SubstrateMethodAccessor
1.51MB i.g.xds.shaded.io.envoyproxy.envoy.config.core.v3 4.27MB byte[] for general heap data
1.47MB com.google.cloud.vision.v1p2beta1 2.50MB com.oracle.svm.core.hub.DynamicHubCompanion
1.34MB i.g.x.shaded.io.envoyproxy.envoy.config.route.v3 1.17MB java.lang.Object[]
58.34MB for 977 more packages 9.19MB for 4667 more object types
------------------------------------------------------------------------------------------------------------------------
13.5s (5.7% of total time) in 75 GCs | Peak RSS: 9.44GB | CPU load: 6.13
------------------------------------------------------------------------------------------------------------------------
Produced artifacts:
/home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis (executable)
/home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis.build_artifacts.txt (txt)
========================================================================================================================
Finished generating '/home/user/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis' in 3m 57s.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 04:28 min
[INFO] Finished at: 2023-10-10T19:53:30Z
[INFO] ------------------------------------------------------------------------
11. Criar e publicar imagens de contêiner
Vamos criar uma imagem do contêiner em duas versões diferentes: uma como JIT image e outra como Native Java image.
Primeiro, defina as variáveis de ambiente do projeto do GCP:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
Crie a imagem JIT:
./mvnw spring-boot:build-image -Pji
Observe o registro de build no terminal:
[INFO] [creator] Timer: Saving docker.io/library/image-analysis-maven-jit:latest... started at 2023-10-10T20:00:31Z [INFO] [creator] *** Images (4c84122a1826): [INFO] [creator] docker.io/library/image-analysis-maven-jit:latest [INFO] [creator] Timer: Saving docker.io/library/image-analysis-maven-jit:latest... ran for 6.975913605s and ended at 2023-10-10T20:00:38Z [INFO] [creator] Timer: Exporter ran for 8.068588001s and ended at 2023-10-10T20:00:38Z [INFO] [creator] Timer: Cache started at 2023-10-10T20:00:38Z [INFO] [creator] Reusing cache layer 'paketo-buildpacks/syft:syft' [INFO] [creator] Adding cache layer 'buildpacksio/lifecycle:cache.sbom' [INFO] [creator] Timer: Cache ran for 200.449002ms and ended at 2023-10-10T20:00:38Z [INFO] [INFO] Successfully built image 'docker.io/library/image-analysis-maven-jit:latest' [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 43.887 s [INFO] Finished at: 2023-10-10T20:00:39Z [INFO] ------------------------------------------------------------------------
Crie a imagem AOT(nativa):
./mvnw spring-boot:build-image -Pnative
Observe o registro do build no terminal, incluindo os registros do build de imagem nativa.
Observação:
- que o build leva um pouco mais de tempo, dependendo da máquina em que você está testando
- As imagens podem ser ainda mais compactadas com UPX, mas têm um pequeno impacto negativo na performance de inicialização. Por isso, este build não usa UPX. É sempre uma pequena troca.
... [INFO] [creator] Saving docker.io/library/image-analysis-maven-native:latest... [INFO] [creator] *** Images (13167702674e): [INFO] [creator] docker.io/library/image-analysis-maven-native:latest [INFO] [creator] Adding cache layer 'paketo-buildpacks/bellsoft-liberica:native-image-svm' [INFO] [creator] Adding cache layer 'paketo-buildpacks/syft:syft' [INFO] [creator] Adding cache layer 'paketo-buildpacks/native-image:native-image' [INFO] [creator] Adding cache layer 'buildpacksio/lifecycle:cache.sbom' [INFO] [INFO] Successfully built image 'docker.io/library/image-analysis-maven-native:latest' [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 03:37 min [INFO] Finished at: 2023-10-10T20:05:16Z [INFO] ------------------------------------------------------------------------
Valide se as imagens foram criadas:
docker images | grep image-analysis
Marque e envie as duas imagens para o GCR:
# JIT image
docker tag image-analysis-maven-jit gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-jit
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-jit
# Native(AOT) image
docker tag image-analysis-maven-native gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-native
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-native
12. Implantar no Cloud Run
É hora de implantar o serviço.
Você vai implantar o serviço duas vezes, uma usando a imagem JIT e a segunda usando a imagem AOT(nativa). As duas implantações de serviço vão processar a mesma imagem do bucket em paralelo para fins de comparação.
Primeiro, defina as variáveis de ambiente do projeto do GCP:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
gcloud config set project ${GOOGLE_CLOUD_PROJECT}
gcloud config set run/region
gcloud config set run/platform managed
gcloud config set eventarc/location europe-west1
Implante a imagem JIT e observe o registro de implantação no console:
gcloud run deploy image-analysis-jit \
--image gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-jit \
--region europe-west1 \
--memory 2Gi --allow-unauthenticated
...
Deploying container to Cloud Run service [image-analysis-jit] in project [...] region [europe-west1]
✓ Deploying... Done.
✓ Creating Revision...
✓ Routing traffic...
✓ Setting IAM Policy...
Done.
Service [image-analysis-jit] revision [image-analysis-jvm-00009-huc] has been deployed and is serving 100 percent of traffic.
Service URL: https://image-analysis-jit-...-ew.a.run.app
Implante a imagem nativa e observe o registro de implantação no console:
gcloud run deploy image-analysis-native \
--image gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-maven-native \
--region europe-west1 \
--memory 2Gi --allow-unauthenticated
...
Deploying container to Cloud Run service [image-analysis-native] in project [...] region [europe-west1]
✓ Deploying... Done.
✓ Creating Revision...
✓ Routing traffic...
✓ Setting IAM Policy...
Done.
Service [image-analysis-native] revision [image-analysis-native-00005-ben] has been deployed and is serving 100 percent of traffic.
Service URL: https://image-analysis-native-...-ew.a.run.app
13. Configurar gatilhos do Eventarc
O Eventarc oferece uma solução padronizada para gerenciar o fluxo de mudanças de estado, chamadas de eventos, entre microsserviços separados. Quando acionado, o Eventarc encaminha esses eventos por meio de assinaturas do Pub/Sub para vários destinos (neste documento, consulte Destinos de eventos) enquanto gerencia a entrega, a segurança, a autorização, a observabilidade e o tratamento de erros para você.
É possível criar um gatilho do Eventarc para que o serviço do Cloud Run receba notificações de um evento especificado ou conjunto de eventos. Ao especificar filtros para o gatilho, é possível configurar o roteamento do evento, incluindo a origem do evento e o serviço de destino do Cloud Run.
Primeiro, defina as variáveis de ambiente do projeto do GCP:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
gcloud config set project ${GOOGLE_CLOUD_PROJECT}
gcloud config set run/region
gcloud config set run/platform managed
gcloud config set eventarc/location europe-west1
Conceda pubsub.publisher à conta de serviço do Cloud Storage:
SERVICE_ACCOUNT="$(gsutil kms serviceaccount -p ${GOOGLE_CLOUD_PROJECT})"
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
--member="serviceAccount:${SERVICE_ACCOUNT}" \
--role='roles/pubsub.publisher'
Configure gatilhos do Eventarc para imagens de serviço JIT e nativas para processar a imagem:
gcloud eventarc triggers list --location=eu
gcloud eventarc triggers create image-analysis-jit-trigger \
--destination-run-service=image-analysis-jit \
--destination-run-region=europe-west1 \
--location=eu \
--event-filters="type=google.cloud.storage.object.v1.finalized" \
--event-filters="bucket=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}" \
--service-account=${PROJECT_NUMBER}-compute@developer.gserviceaccount.com
gcloud eventarc triggers create image-analysis-native-trigger \
--destination-run-service=image-analysis-native \
--destination-run-region=europe-west1 \
--location=eu \
--event-filters="type=google.cloud.storage.object.v1.finalized" \
--event-filters="bucket=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}" \
--service-account=${PROJECT_NUMBER}-compute@developer.gserviceaccount.com
Observe que os dois acionadores foram criados:
gcloud eventarc triggers list --location=eu
14. Testar versões de serviço
Depois que as implantações de serviço forem bem-sucedidas, você vai postar uma foto no Cloud Storage, verificar se os serviços foram invocados, o que a API Vision retorna e se os metadados são armazenados no Firestore.
Volte para Cloud Storage e clique no bucket que criamos no início do laboratório:
Na página de detalhes do bucket, clique no botão Upload files para fazer upload de uma imagem.
Por exemplo, uma imagem GeekHour.jpeg é fornecida com sua base de código em /services/image-analysis/java. Selecione uma imagem e pressione Open button:
Agora é possível verificar a execução do serviço, começando com image-analysis-jit e depois image-analysis-native.
No menu "hambúrguer" (☰), acesse o serviço Cloud Run > image-analysis-jit.
Clique em "Registros" e observe a saída:
E, de fato, na lista de registros, posso ver que o serviço JIT image-analysis-jit foi invocado.
Os registros indicam o início e o fim da execução do serviço. Entre eles, podemos ver os registros que colocamos na função com as instruções de registro no nível INFO. Podemos notar que:
- Os detalhes do evento que aciona nossa função,
- Os resultados brutos da chamada da API Vision,
- Os rótulos encontrados na imagem que enviamos,
- As informações de cores dominantes,
- Se a imagem é segura para mostrar,
- E, por fim, esses metadados sobre a imagem foram armazenados no Firestore.
Repita o processo para o serviço image-analysis-native.
No menu "hambúrguer" (☰), acesse o serviço Cloud Run > image-analysis-native.
Clique em "Registros" e observe a saída:
Agora, observe se os metadados da imagem foram armazenados no Fiorestore.
No menu "hambúrguer" (☰), acesse a seção Firestore. Na subseção Data (mostrada por padrão), você vai encontrar a coleção pictures com um novo documento adicionado, correspondente à imagem que você acabou de enviar:
15. Limpeza (opcional)
Se você não pretende continuar com os outros laboratórios da série, limpe os recursos para economizar custos e ser um bom usuário da nuvem. É possível limpar os recursos individualmente da seguinte maneira.
Excluir o bucket:
gsutil rb gs://${BUCKET_PICTURES}
Exclua a função:
gcloud functions delete picture-uploaded --region europe-west1 -q
Exclua a coleção do Firestore selecionando "Excluir coleção" na coleção:
Se preferir, exclua todo o projeto:
gcloud projects delete ${GOOGLE_CLOUD_PROJECT}
16. Parabéns!
Parabéns! Você implementou o primeiro serviço de chaves do projeto!
O que vimos
- Cloud Storage
- Cloud Run
- API Cloud Vision
- Cloud Firestore
- Imagens nativas em Java