1. Visão geral
No primeiro codelab, você vai armazenar imagens 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 chamará a API Vision para fazer a análise de imagens e salvar os resultados em um repositório de dados.
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 Você pode atualizar a qualquer momento.
- O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser alterado após a definição. O console do Cloud gera automaticamente uma string exclusiva. normalmente você não se importa com o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, que normalmente é identificado como
PROJECT_ID. Se você não gostar do ID gerado, poderá gerar outro ID aleatório. Como alternativa, você pode tentar o seu próprio e ver se ele está disponível. Ela não pode ser alterada após esta etapa e permanecerá durante a duração do projeto. - Para sua informação, há um terceiro valor, um Número de 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 será muito cara, se tiver algum custo. Para encerrar os recursos e não gerar faturamento além deste tutorial, exclua os recursos criados ou exclua o projeto inteiro. 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ê usará o Cloud Functions e a API Vision, mas primeiro eles precisam ser ativados no console do Cloud ou com o gcloud.
Para ativar a API Vision no Console do Cloud, procure Cloud Vision API na barra de pesquisa:
Você será direcionado à página da API Cloud Vision:
Clique no botão ENABLE.
Se preferir, ative o Cloud Shell usando a ferramenta de linha de comando gcloud.
No Cloud Shell, execute o seguinte comando:
gcloud services enable vision.googleapis.com
Você verá que 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)
Criar um bucket de armazenamento para as imagens. Faça isso no console do Google Cloud Platform ( console.cloud.google.com) ou com a ferramenta de linha de comando gsutil do Cloud Shell ou seu ambiente de desenvolvimento local.
Acesse "Armazenamento"
No menu "hambúrguer", (☰) menu, 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 publicamente, o ideal é que todas as nossas imagens armazenadas no 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 do armazenamento
Acesse a guia Permissions:
Adicione um membro allUsers ao bucket, com um papel de 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 seu ID do projeto exclusivo. É possível anexar isso ao nome do bucket.
Exemplo:
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
Crie uma zona multirregional padrão na Europa:
gsutil mb -l EU gs://${BUCKET_PICTURES}
Garanta acesso uniforme no nível do bucket:
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, terá um bucket uploaded-pictures público:
Verifique se é possível fazer upload das imagens para o bucket e se elas estão disponíveis publicamente, conforme explicado na etapa anterior.
6. Testar o acesso público ao bucket
De volta ao navegador do Storage, você verá seu bucket na lista, com "Público" acesso (incluindo um sinal de aviso para lembrar que qualquer pessoa tem acesso ao conteúdo desse bucket).
Seu bucket está pronto para receber imagens.
Se clicar no nome do bucket, você verá os detalhes dele.
Lá, você pode usar o botão Upload files para testar se é possível adicionar uma imagem ao bucket. Um pop-up do seletor de arquivos solicitará que você escolha um arquivo. Depois de selecionado, ele será enviado para seu bucket, e você verá novamente o acesso public que foi atribuído automaticamente a esse novo arquivo.
Junto ao marcador de acesso Public, você também verá um pequeno ícone de link. Ao clicar nela, o navegador navegará para o URL público dessa imagem, que terá o seguinte formato:
https://storage.googleapis.com/BUCKET_NAME/PICTURE_FILE.png
No qual BUCKET_NAME é o nome globalmente exclusivo escolhido para o bucket e depois 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 esta primeira imagem.
7. Preparar o banco de dados
Você vai armazenar informações sobre a imagem fornecida pela API Vision no banco de dados do Cloud Firestore, um banco de dados de documentos NoSQL rápido, totalmente gerenciado, sem servidor e nativo da nuvem. Prepare o banco de dados acessando a seção Firestore do Console do Cloud:
Há duas opções disponíveis: 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 um local multirregional (aqui na Europa, mas idealmente 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 nova coleção clicando no botão + START COLLECTION.
Conjunto de nomes pictures.
Não é necessário criar um documento. Você as adicionará programaticamente à 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. É possível excluir esse documento com segurança, já que ele não contém informações úteis:
Os documentos que serão criados programaticamente na nossa coleção terão 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 de cor hexadecimal da cor dominante (ou seja, #ab12ef).
- created (data): o carimbo de data/hora de quando os metadados da imagem foram armazenados
- miniatura (booleano): um campo opcional que vai estar presente e ser verdadeiro se uma imagem em miniatura tiver sido gerada para a imagem
Como vamos pesquisar no Firestore para encontrar imagens que tenham miniaturas disponíveis e classificar ao longo da data de criação, precisaremos 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
Também é possível fazer isso no Console do Cloud, clicando em Indexes na coluna de navegação à esquerda e criando 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
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. conheça o código de serviço
Para começar, veja como as bibliotecas de cliente do Java são ativadas no pom.xml usando uma BoM:
Primeiro, edite o arquivo pom.xml, que lista as dependências da função Java. Atualize o código para adicionar a dependência Maven da API Cloud Vision:
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cloudfunctions</groupId>
<artifactId>gcs-function</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.target>11</maven.compiler.target>
<maven.compiler.source>11</maven.compiler.source>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>libraries-bom</artifactId>
<version>26.1.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.cloud.functions</groupId>
<artifactId>functions-framework-api</artifactId>
<version>1.0.4</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>
</dependencies>
A funcionalidade é implementada na classe EventController. Sempre que uma nova imagem é carregada no 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 continuar para 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 solicitação 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 solicitando três recursos principais da API Vision:
- Detecção de rótulos: para entender o que aparece nessas fotos.
- Propriedades de imagem: para fornecer atributos interessantes da imagem (estamos interessados na cor dominante da imagem)
- Pesquisa segura: para saber se a imagem é segura para exibição (ela não deve conter conteúdo adulto / médico / potencialmente ofensivo / violento)
Agora, podemos fazer a chamada para a API Vision:
...
logger.info("Calling the Vision API...");
BatchAnnotateImagesResponse result = vision.batchAnnotateImages(requests);
List<AnnotateImageResponse> responses = result.getResponsesList();
...
Como referência, confira 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 nenhum erro for retornado, podemos prosseguir. É por isso que 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 obter 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);
}
Estamos interessados em 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 pode ser exibida:
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 / paródia / médica / violência / conteúdo potencialmente ofensivo para ver se elas são prováveis ou muito prováveis.
Se o resultado da pesquisa segura estiver correto, poderemos armazenar os metadados no Firestore:
// Saving result to Firestore
if (isSafe) {
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());
ApiFuture<WriteResult> writeResult = doc.set(data, SetOptions.merge());
logger.info("Picture metadata saved in Firestore at " + writeResult.get().getUpdateTime());
}
10. Criar imagens de apps com o GraalVM (opcional)
Nesta etapa opcional, você vai criar um JIT(JVM) based app image e depois um AOT(Native) Java app image usando o GraalVM.
Para executar a compilação, será necessário garantir que você tenha um JDK apropriado e o criador de imagens nativas instalados e configurados. Há várias opções disponíveis.
To start, faça o download do GraalVM 22.2.x Community Edition e siga as instruções na página de instalação do GraalVM.
Esse processo pode ser bastante simplificado com a ajuda do SDKMAN!
Para instalar a distribuição JDK adequada com SDKman, comece usando o comando de instalação:
sdk install java 22.2.r17-grl
Instrua o SDKman a usar essa versão para builds JIT e AOT:
sdk use java 22.2.0.r17-grl
Instale o native-image utility para GraalVM:
gu install native-image
No Cloudshell, para facilitar, instale o GraalVM e o utilitário de imagem nativa com estes comandos simples:
# install GraalVM in your home directory cd ~ # download GraalVM wget https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-22.2.0/graalvm-ce-java17-linux-amd64-22.2.0.tar.gz ls tar -xzvf graalvm-ce-java17-linux-amd64-22.2.0.tar.gz # configure Java 17 and GraalVM 22.2 echo Existing JVM: $JAVA_HOME cd graalvm-ce-java17-22.2.0 export JAVA_HOME=$PWD cd bin export PATH=$PWD:$PATH echo JAVA HOME: $JAVA_HOME echo PATH: $PATH # install the native image utility java -version gu install native-image cd ../..
Primeiro defina as variáveis de ambiente do projeto do GCP:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
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(JVM):
./mvnw package -Pjvm
Observe o registro do build no terminal:
... [INFO] --- spring-boot-maven-plugin:2.7.3:repackage (repackage) @ image-analysis --- [INFO] Replacing main artifact with repackaged archive [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 24.009 s [INFO] Finished at: 2022-09-26T22:17:32-04:00 [INFO] ------------------------------------------------------------------------
Crie a imagem AOT(nativa):
./mvnw package -Pnative -DskipTests
Observe o registro do build no terminal, incluindo os registros de build da imagem nativa:
Observe que o build demora um pouco mais, dependendo da máquina em que você está testando.
...
[2/7] Performing analysis... [**********] (95.4s @ 3.57GB)
23,346 (94.42%) of 24,725 classes reachable
44,625 (68.71%) of 64,945 fields reachable
163,759 (70.79%) of 231,322 methods reachable
989 classes, 1,402 fields, and 11,032 methods registered for reflection
63 classes, 69 fields, and 55 methods registered for JNI access
5 native libraries: -framework CoreServices, -framework Foundation, dl, pthread, z
[3/7] Building universe... (10.0s @ 5.35GB)
[4/7] Parsing methods... [***] (9.7s @ 3.13GB)
[5/7] Inlining methods... [***] (4.5s @ 3.29GB)
[6/7] Compiling methods... [[6/7] Compiling methods... [********] (67.6s @ 5.72GB)
[7/7] Creating image... (8.7s @ 4.59GB)
62.21MB (54.80%) for code area: 100,371 compilation units
50.98MB (44.91%) for image heap: 465,035 objects and 365 resources
337.09KB ( 0.29%) for other data
113.52MB in total
------------------------------------------------------------------------------------------------------------------------
Top 10 packages in code area: Top 10 object types in image heap:
2.36MB com.google.protobuf 12.70MB byte[] for code metadata
1.90MB i.g.xds.shaded.io.envoyproxy.envoy.config.core.v3 6.66MB java.lang.Class
1.73MB i.g.x.shaded.io.envoyproxy.envoy.config.route.v3 6.47MB byte[] for embedded resources
1.67MB sun.security.ssl 4.61MB byte[] for java.lang.String
1.54MB com.google.cloud.vision.v1 4.37MB java.lang.String
1.46MB com.google.firestore.v1 3.38MB byte[] for general heap data
1.37MB io.grpc.xds.shaded.io.envoyproxy.envoy.api.v2.core 1.96MB com.oracle.svm.core.hub.DynamicHubCompanion
1.32MB i.g.xds.shaded.io.envoyproxy.envoy.api.v2.route 1.80MB byte[] for reflection metadata
1.09MB java.util 911.80KB java.lang.String[]
1.08MB com.google.re2j 826.48KB c.o.svm.core.hub.DynamicHub$ReflectionMetadata
45.91MB for 772 more packages 6.45MB for 3913 more object types
------------------------------------------------------------------------------------------------------------------------
15.1s (6.8% of total time) in 56 GCs | Peak RSS: 7.72GB | CPU load: 4.37
------------------------------------------------------------------------------------------------------------------------
Produced artifacts:
/Users/ddobrin/work/dan/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis (executable)
/Users/ddobrin/work/dan/serverless-photosharing-workshop/services/image-analysis/java/target/image-analysis.build_artifacts.txt (txt)
========================================================================================================================
Finished generating 'image-analysis' in 3m 41s.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 03:56 min
[INFO] Finished at: 2022-09-26T22:22:29-04:00
[INFO] ------------------------------------------------------------------------
11. Criar e publicar imagens de contêiner
Vamos criar uma imagem de contêiner em duas versões diferentes: uma como JIT(JVM) image e outra como AOT(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(JVM):
./mvnw package -Pjvm-image
Observe o registro do build no terminal:
[INFO] [creator] Adding layer 'process-types' [INFO] [creator] Adding label 'io.buildpacks.lifecycle.metadata' [INFO] [creator] Adding label 'io.buildpacks.build.metadata' [INFO] [creator] Adding label 'io.buildpacks.project.metadata' [INFO] [creator] Adding label 'org.opencontainers.image.title' [INFO] [creator] Adding label 'org.opencontainers.image.version' [INFO] [creator] Adding label 'org.springframework.boot.version' [INFO] [creator] Setting default process type 'web' [INFO] [creator] Saving docker.io/library/image-analysis-jvm:r17... [INFO] [creator] *** Images (03a44112456e): [INFO] [creator] docker.io/library/image-analysis-jvm:r17 [INFO] [creator] Adding cache layer 'paketo-buildpacks/syft:syft' [INFO] [creator] Adding cache layer 'cache.sbom' [INFO] [INFO] Successfully built image 'docker.io/library/image-analysis-jvm:r17' [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 02:11 min [INFO] Finished at: 2022-09-26T13:09:34-04:00 [INFO] ------------------------------------------------------------------------
Crie a imagem AOT(nativa):
./mvnw package -Pnative-image
Observe o registro do build no terminal, incluindo os registros de build da imagem nativa e a compactação de imagens usando UPX.
Observe que o build demora um pouco mais, dependendo da máquina em que você está testando
... [INFO] [creator] [2/7] Performing analysis... [***********] (147.6s @ 3.10GB) [INFO] [creator] 23,362 (94.34%) of 24,763 classes reachable [INFO] [creator] 44,657 (68.67%) of 65,029 fields reachable [INFO] [creator] 163,926 (70.76%) of 231,656 methods reachable [INFO] [creator] 981 classes, 1,402 fields, and 11,026 methods registered for reflection [INFO] [creator] 63 classes, 68 fields, and 55 methods registered for JNI access [INFO] [creator] 4 native libraries: dl, pthread, rt, z [INFO] [creator] [3/7] Building universe... (21.1s @ 2.66GB) [INFO] [creator] [4/7] Parsing methods... [****] (13.7s @ 4.16GB) [INFO] [creator] [5/7] Inlining methods... [***] (9.6s @ 4.20GB) [INFO] [creator] [6/7] Compiling methods... [**********] (107.6s @ 3.36GB) [INFO] [creator] [7/7] Creating image... (14.7s @ 4.87GB) [INFO] [creator] 62.24MB (51.35%) for code area: 100,499 compilation units [INFO] [creator] 51.99MB (42.89%) for image heap: 473,948 objects and 473 resources [INFO] [creator] 6.98MB ( 5.76%) for other data [INFO] [creator] 121.21MB in total [INFO] [creator] -------------------------------------------------------------------------------- [INFO] [creator] Top 10 packages in code area: Top 10 object types in image heap: [INFO] [creator] 2.36MB com.google.protobuf 12.71MB byte[] for code metadata [INFO] [creator] 1.90MB i.g.x.s.i.e.e.config.core.v3 7.59MB byte[] for embedded resources [INFO] [creator] 1.73MB i.g.x.s.i.e.e.config.route.v3 6.66MB java.lang.Class [INFO] [creator] 1.67MB sun.security.ssl 4.62MB byte[] for java.lang.String [INFO] [creator] 1.54MB com.google.cloud.vision.v1 4.39MB java.lang.String [INFO] [creator] 1.46MB com.google.firestore.v1 3.66MB byte[] for general heap data [INFO] [creator] 1.37MB i.g.x.s.i.e.envoy.api.v2.core 1.96MB c.o.s.c.h.DynamicHubCompanion [INFO] [creator] 1.32MB i.g.x.s.i.e.e.api.v2.route 1.80MB byte[] for reflection metadata [INFO] [creator] 1.09MB java.util 910.41KB java.lang.String[] [INFO] [creator] 1.08MB com.google.re2j 826.95KB c.o.s.c.h.DynamicHu~onMetadata [INFO] [creator] 45.94MB for 776 more packages 6.69MB for 3916 more object types [INFO] [creator] -------------------------------------------------------------------------------- [INFO] [creator] 20.4s (5.6% of total time) in 81 GCs | Peak RSS: 6.75GB | CPU load: 4.53 [INFO] [creator] -------------------------------------------------------------------------------- [INFO] [creator] Produced artifacts: [INFO] [creator] /layers/paketo-buildpacks_native-image/native-image/services.ImageAnalysisApplication (executable) [INFO] [creator] /layers/paketo-buildpacks_native-image/native-image/services.ImageAnalysisApplication.build_artifacts.txt (txt) [INFO] [creator] ================================================================================ [INFO] [creator] Finished generating '/layers/paketo-buildpacks_native-image/native-image/services.ImageAnalysisApplication' in 5m 59s. [INFO] [creator] Executing upx to compress native image [INFO] [creator] Ultimate Packer for eXecutables [INFO] [creator] Copyright (C) 1996 - 2020 [INFO] [creator] UPX 3.96 Markus Oberhumer, Laszlo Molnar & John Reiser Jan 23rd 2020 [INFO] [creator] [INFO] [creator] File size Ratio Format Name [INFO] [creator] -------------------- ------ ----------- ----------- 127099880 -> 32416676 25.50% linux/amd64 services.ImageAnalysisApplication ... [INFO] [creator] ===> EXPORTING ... [INFO] [creator] Adding cache layer 'paketo-buildpacks/native-image:native-image' [INFO] [creator] Adding cache layer 'cache.sbom' [INFO] [INFO] Successfully built image 'docker.io/library/image-analysis-native:r17' ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 05:28 min [INFO] Finished at: 2022-09-26T13:19:53-04:00 [INFO] ------------------------------------------------------------------------
Valide se as imagens foram criadas:
docker images | grep image-analysis
Marque e envie as duas imagens ao GCR:
# JIT(JVM) image
docker tag image-analysis-jvm:r17 gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-jvm:r17
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-jvm:r17
# AOT(Native) image
docker tag image-analysis-native:r17 gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-native:r17
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-native:r17
12. Implantar no Cloud Run
Hora de implantar o serviço.
Você implantará o serviço duas vezes: uma com a imagem JIT(JVM) e a segunda com a imagem AOT(nativa). As duas implantações de serviço processarão 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(JVM) e observe o registro de implantação no console:
gcloud run deploy image-analysis-jvm \
--image gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-jvm:r17 \
--region europe-west1 \
--memory 2Gi --allow-unauthenticated
...
Deploying container to Cloud Run service [image-analysis-jvm] in project [...] region [europe-west1]
✓ Deploying... Done.
✓ Creating Revision...
✓ Routing traffic...
✓ Setting IAM Policy...
Done.
Service [image-analysis-jvm] revision [image-analysis-jvm-00009-huc] has been deployed and is serving 100 percent of traffic.
Service URL: https://image-analysis-jvm-...-ew.a.run.app
Implante a imagem AOT(nativa) e observe o registro de implantação no console:
gcloud run deploy image-analysis-native \
--image gcr.io/${GOOGLE_CLOUD_PROJECT}/image-analysis-native:r17 \
--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 alterações de estado, chamadas de eventos, entre microsserviços separados. Quando acionado, o Eventarc encaminha esses eventos usando assinaturas do Pub/Sub para vários destinos (neste documento, consulte "Destinos de eventos") enquanto gerencia entrega, segurança, autorização, observabilidade e tratamento de erros.
É possível criar um gatilho do Eventarc para que o serviço do Cloud Run receba notificações de um evento ou conjunto de eventos especificado. 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 JVM(JIT) e AOT(nativas) para processar a imagem:
gcloud eventarc triggers list --location=eu
gcloud eventarc triggers create image-analysis-jvm-trigger \
--destination-run-service=image-analysis-jvm \
--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
Os dois acionadores foram criados:
gcloud eventarc triggers list --location=eu
14. Testar versões de serviço
Quando as implantações do serviço forem concluídas, você publicará uma imagem no Cloud Storage para ver se nossos serviços foram invocados, o que a API Vision retorna e se os metadados estão armazenados no Firestore.
Navegue de volta 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-jvm, seguido por image-analysis-native.
No menu "hambúrguer", (☰) menu, navegue até o serviço Cloud Run > image-analysis-jvm.
Clique em "Logs" e observe a saída:
Na lista de registros, é possível ver que o serviço JIT(JVM) image-analysis-jvm foi invocado.
Os registros indicam o início e o fim da execução do serviço. E, enquanto isso, podemos ver os registros que colocamos na função com os log statements no nível INFO. Vemos:
- Os detalhes do evento que aciona a função,
- Os resultados brutos da chamada da API Vision
- Os marcadores que foram encontrados na imagem que carregamos,
- As informações sobre cores dominantes,
- Se a imagem pode ser exibida,
- Por fim, os metadados sobre a imagem foram armazenados no Firestore.
Você repetirá o processo para o serviço image-analysis-native.
No menu "hambúrguer", (☰) menu, navegue até o serviço Cloud Run > image-analysis-native.
Clique em "Logs" e observe a saída:
Observe agora se os metadados da imagem foram armazenados no Fiorestore.
Mais uma vez, no "hambúrguer", (☰) no menu, 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 cidadão da nuvem. É possível limpar 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
Para excluir a coleção do Firestore, selecione "Excluir coleção da 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 do Java