1. खास जानकारी
पहले कोड लैब में, आपको एक बकेट में फ़ोटो सेव करनी होंगी. इससे फ़ाइल बनाने का एक इवेंट जनरेट होगा. इसे Cloud Run में डिप्लॉय की गई सेवा मैनेज करेगी. यह सेवा, इमेज का विश्लेषण करने के लिए Vision API को कॉल करेगी और नतीजों को डेटास्टोर में सेव करेगी.
आपको क्या सीखने को मिलेगा
- Cloud Storage
- Cloud Run
- Cloud Vision API
- Cloud Firestore
2. सेटअप और ज़रूरी शर्तें
अपने हिसाब से एनवायरमेंट सेट अप करना
- Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.
- प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे कभी भी अपडेट किया जा सकता है.
- प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, यूनीक स्ट्रिंग को अपने-आप जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी (आम तौर पर
PROJECT_IDके तौर पर पहचाना जाता है) का रेफ़रंस देना होगा. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट किया जा सकता है. इसके अलावा, आपके पास अपना नाम आज़माने का विकल्प भी है. इससे आपको पता चलेगा कि वह नाम उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट की अवधि तक बना रहता है. - आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
- इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा समय नहीं लगेगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, संसाधनों को बंद किया जा सकता है. इसके लिए, बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, 300 डॉलर का क्रेडिट मिलेगा. वे इसे मुफ़्त में आज़मा सकते हैं.
Cloud Shell शुरू करें
Google Cloud को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में Google Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Google Cloud Console में, सबसे ऊपर दाएं कोने में मौजूद टूलबार पर, Cloud Shell आइकॉन पर क्लिक करें:
इसे चालू करने और एनवायरमेंट से कनेक्ट करने में सिर्फ़ कुछ सेकंड लगेंगे. यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:
इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, यह Google Cloud पर काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में मौजूद सभी टास्क, ब्राउज़र में किए जा सकते हैं. आपको कुछ भी इंस्टॉल करने की ज़रूरत नहीं है.
3. एपीआई चालू करें
इस लैब के लिए, Cloud Functions और Vision API का इस्तेमाल किया जाएगा. हालांकि, इससे पहले इन्हें Cloud Console या gcloud में चालू करना होगा.
Cloud Console में Vision API को चालू करने के लिए, खोज बार में Cloud Vision API खोजें:
आपको Cloud Vision API का पेज दिखेगा:
ENABLE बटन पर क्लिक करें.
इसके अलावा, gcloud कमांड लाइन टूल का इस्तेमाल करके, Cloud Shell में भी इसे चालू किया जा सकता है.
Cloud Shell में, यह कमांड चलाएं:
gcloud services enable vision.googleapis.com
आपको यह कार्रवाई पूरी होने का मैसेज दिखेगा:
Operation "operations/acf.12dba18b-106f-4fd2-942d-fea80ecc5c1c" finished successfully.
Cloud Run और Cloud Build को भी चालू करें:
gcloud services enable cloudbuild.googleapis.com \ run.googleapis.com
4. बकेट बनाना (कंसोल)
फ़ोटो के लिए स्टोरेज बकेट बनाएं. इसे Google Cloud Platform Console ( console.cloud.google.com) से किया जा सकता है. इसके अलावा, Cloud Shell या अपने लोकल डेवलपमेंट एनवायरमेंट से gsutil कमांड लाइन टूल का इस्तेमाल करके भी ऐसा किया जा सकता है.
स्टोरेज पर जाएं
"हैमबर्गर" (☰) मेन्यू में जाकर, Storage पेज पर जाएं.
अपने बकेट का नाम डालें
CREATE BUCKET बटन पर क्लिक करें.
CONTINUE पर क्लिक करें.
जगह की जानकारी चुनें
अपनी पसंद के क्षेत्र (यहां Europe) में एक से ज़्यादा क्षेत्रों के लिए बकेट बनाएं.
CONTINUE पर क्लिक करें.
डिफ़ॉल्ट स्टोरेज क्लास चुनना
अपने डेटा के लिए Standard स्टोरेज क्लास चुनें.
CONTINUE पर क्लिक करें.
ऐक्सेस कंट्रोल सेट करना
आपको सार्वजनिक तौर पर उपलब्ध इमेज के साथ काम करना है. इसलिए, आपको यह पक्का करना होगा कि इस बकेट में सेव की गई हमारी सभी इमेज के लिए, ऐक्सेस कंट्रोल एक जैसा हो.
Uniform ऐक्सेस कंट्रोल का विकल्प चुनें.
CONTINUE पर क्लिक करें.
सुरक्षा/एन्क्रिप्शन सेट करना
डिफ़ॉल्ट विकल्प (Google-managed key)) को चुनें, क्योंकि आपको अपने एन्क्रिप्शन कुंजियों का इस्तेमाल नहीं करना है.
बकेट बनाने की प्रोसेस पूरी करने के लिए, CREATE पर क्लिक करें.
allUsers को स्टोरेज व्यूअर के तौर पर जोड़ना
Permissions टैब पर जाएं:
allUsers सदस्य को बकेट में जोड़ें. इसके लिए, Storage > Storage Object Viewer की भूमिका असाइन करें. इसके लिए, यह तरीका अपनाएं:
SAVE पर क्लिक करें.
5. बकेट बनाना (gsutil)
बकेट बनाने के लिए, Cloud Shell में gsutil कमांड लाइन टूल का भी इस्तेमाल किया जा सकता है.
Cloud Shell में, बकेट के यूनीक नाम के लिए एक वैरिएबल सेट करें. Cloud Shell में, GOOGLE_CLOUD_PROJECT को पहले से ही आपके यूनीक प्रोजेक्ट आईडी पर सेट किया गया है. इसे बकेट के नाम में जोड़ा जा सकता है.
उदाहरण के लिए:
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
यूरोप में एक स्टैंडर्ड मल्टी-रीजन ज़ोन बनाएं:
gsutil mb -l EU gs://${BUCKET_PICTURES}
पक्का करें कि बकेट लेवल का ऐक्सेस एक जैसा हो:
gsutil uniformbucketlevelaccess set on gs://${BUCKET_PICTURES}
बकेट को सार्वजनिक करें:
gsutil iam ch allUsers:objectViewer gs://${BUCKET_PICTURES}
अगर आप कंसोल के Cloud Storage सेक्शन पर जाते हैं, तो आपके पास सार्वजनिक uploaded-pictures बकेट होनी चाहिए:
जांच करें कि बकेट में फ़ोटो अपलोड की जा सकती हैं और अपलोड की गई फ़ोटो सार्वजनिक तौर पर उपलब्ध हैं. इसके बारे में पिछले चरण में बताया गया है.
6. बकेट के सार्वजनिक ऐक्सेस की जांच करना
स्टोरेज ब्राउज़र पर वापस जाने पर, आपको सूची में अपना बकेट दिखेगा. इसका ऐक्सेस "सार्वजनिक" होगा. इसमें एक चेतावनी का निशान भी दिखेगा, जो आपको यह याद दिलाएगा कि किसी के पास भी उस बकेट के कॉन्टेंट का ऐक्सेस है.
अब आपका बकेट, फ़ोटो पाने के लिए तैयार है.
बकेट के नाम पर क्लिक करने से, आपको बकेट की जानकारी दिखेगी.
वहां, Upload files बटन पर क्लिक करके यह जांच की जा सकती है कि बकेट में कोई फ़ोटो जोड़ी जा सकती है या नहीं. फ़ाइल चुनने का विकल्प देने वाला एक पॉप-अप दिखेगा. इसमें आपको कोई फ़ाइल चुनने के लिए कहा जाएगा. चुने जाने के बाद, इसे आपके बकेट में अपलोड कर दिया जाएगा. इसके बाद, आपको public का वह ऐक्सेस फिर से दिखेगा जो इस नई फ़ाइल को अपने-आप मिल गया है.
Public ऐक्सेस लेबल के साथ-साथ, आपको एक छोटा लिंक आइकॉन भी दिखेगा. इस पर क्लिक करने पर, आपका ब्राउज़र उस इमेज के सार्वजनिक यूआरएल पर नेविगेट करेगा. यह यूआरएल इस तरह का होगा:
https://storage.googleapis.com/BUCKET_NAME/PICTURE_FILE.png
इसमें BUCKET_NAME वह यूनीक नाम है जो आपने अपने बकेट के लिए चुना है. इसके बाद, आपकी फ़ोटो का फ़ाइल नाम है.
इमेज के नाम के बगल में मौजूद चेक बॉक्स पर क्लिक करने से, DELETE बटन चालू हो जाएगा. इसके बाद, पहली इमेज को मिटाया जा सकता है.
7. डेटाबेस तैयार करना
Vision API से मिली इमेज की जानकारी को Cloud Firestore डेटाबेस में सेव किया जाएगा. यह एक तेज़, पूरी तरह से मैनेज किया जाने वाला, बिना सर्वर वाला, क्लाउड-नेटिव NoSQL दस्तावेज़ डेटाबेस है. Cloud Console के Firestore सेक्शन में जाकर, अपना डेटाबेस तैयार करें:
इसके दो विकल्प होते हैं: Native mode या Datastore mode. नेटिव मोड का इस्तेमाल करें. इसमें ऑफ़लाइन मोड में काम करने और रीयल-टाइम में सिंक करने जैसी अतिरिक्त सुविधाएं मिलती हैं.
SELECT NATIVE MODE पर क्लिक करें.
एक से ज़्यादा क्षेत्रों वाला विकल्प चुनें. यहां यूरोप को चुना गया है, लेकिन बेहतर होगा कि आप उसी क्षेत्र को चुनें जहां आपका फ़ंक्शन और स्टोरेज बकेट मौजूद हैं.
CREATE DATABASE बटन पर क्लिक करें.
डेटाबेस बन जाने के बाद, आपको यह दिखेगा:
+ START COLLECTION बटन पर क्लिक करके, नया कलेक्शन बनाएं.
नाम इकट्ठा करने की सुविधा pictures.
आपको कोई दस्तावेज़ बनाने की ज़रूरत नहीं है. इन्हें प्रोग्राम के हिसाब से जोड़ा जाएगा, क्योंकि नई फ़ोटो Cloud Storage में सेव की जाती हैं और Vision API उनका विश्लेषण करता है.
Save पर क्लिक करें.
Firestore, नई बनाई गई कलेक्शन में पहला डिफ़ॉल्ट दस्तावेज़ बनाता है. इस दस्तावेज़ को सुरक्षित तरीके से मिटाया जा सकता है, क्योंकि इसमें कोई काम की जानकारी नहीं होती:
हमारे कलेक्शन में प्रोग्राम के हिसाब से बनाए जाने वाले दस्तावेज़ों में चार फ़ील्ड होंगे:
- name (string): अपलोड की गई फ़ोटो का फ़ाइल नाम. यह दस्तावेज़ की कुंजी भी है
- labels (स्ट्रिंग की ऐरे): Vision API से पहचाने गए आइटम के लेबल
- color (string): मुख्य रंग का हेक्साडेसिमल कलर कोड (जैसे, #ab12ef)
- created (date): इस इमेज के मेटाडेटा को सेव किए जाने का टाइमस्टैंप
- thumbnail (बूलियन): यह एक ज़रूरी नहीं है. अगर इस फ़ोटो के लिए थंबनेल इमेज जनरेट की गई है, तो यह फ़ील्ड मौजूद होगा और इसकी वैल्यू true होगी
हमें Firestore में उन फ़ोटो को खोजना है जिनके थंबनेल उपलब्ध हैं. साथ ही, उन्हें बनाने की तारीख के हिसाब से क्रम से लगाना है. इसलिए, हमें एक खोज इंडेक्स बनाना होगा.
Cloud Shell में, इस निर्देश का इस्तेमाल करके इंडेक्स बनाया जा सकता है:
gcloud firestore indexes composite create \
--collection-group=pictures \
--field-config field-path=thumbnail,order=descending \
--field-config field-path=created,order=descending
इसके अलावा, Cloud Console से भी ऐसा किया जा सकता है. इसके लिए, बाईं ओर मौजूद नेविगेशन कॉलम में Indexes पर क्लिक करें. इसके बाद, यहां दिए गए तरीके से कंपोज़िट इंडेक्स बनाएं:
Create पर क्लिक करें. इंडेक्स बनाने में कुछ मिनट लग सकते हैं.
8. कोड क्लोन करना
अगर आपने पिछले कोड लैब में कोड को क्लोन नहीं किया है, तो इसे क्लोन करें:
git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop
इसके बाद, लैब बनाने के लिए उस डायरेक्ट्री पर जाएं जिसमें सेवा मौजूद है:
cd serverless-photosharing-workshop/services/image-analysis/java
सेवा के लिए, आपके पास फ़ाइल का यह लेआउट होगा:
9. सेवा कोड के बारे में जानें
सबसे पहले, यह देखें कि बीओएम का इस्तेमाल करके, pom.xml में Java क्लाइंट लाइब्रेरी कैसे चालू की जाती हैं:
सबसे पहले, pom.xml फ़ाइल खोलें. इसमें हमारे Java ऐप्लिकेशन की डिपेंडेंसी की सूची दी गई है. इसमें Vision, Cloud Storage, और Firestore API के इस्तेमाल पर फ़ोकस किया गया है
<?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>
यह सुविधा EventController क्लास में लागू की गई है. जब भी बकेट में कोई नई इमेज अपलोड की जाएगी, तब सेवा को प्रोसेस करने के लिए सूचना मिलेगी:
@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 {
...
}
यह कोड, 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);
}
अब अनुरोध बनाया जा सकता है. कोड, 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);
हम Vision API की तीन मुख्य क्षमताओं के बारे में पूछ रहे हैं:
- लेबल का पता लगाना: इससे यह समझने में मदद मिलती है कि उन फ़ोटो में क्या है
- इमेज की प्रॉपर्टी: इमेज के दिलचस्प एट्रिब्यूट के बारे में जानकारी देने के लिए (हमें इमेज के मुख्य रंग के बारे में जानकारी चाहिए)
- सेफ़ सर्च: यह जानने के लिए कि इमेज को दिखाना सुरक्षित है या नहीं. इसमें वयस्कों के लिए बना कॉन्टेंट, मेडिकल कॉन्टेंट, अश्लील कॉन्टेंट या हिंसक कॉन्टेंट नहीं होना चाहिए
इस समय, हम Vision API को कॉल कर सकते हैं:
...
logger.info("Calling the Vision API...");
BatchAnnotateImagesResponse result = vision.batchAnnotateImages(requests);
List<AnnotateImageResponse> responses = result.getResponsesList();
...
यहां Vision API से मिलने वाले जवाब का उदाहरण दिया गया है:
{
"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
}
अगर कोई गड़बड़ी नहीं होती है, तो हम आगे बढ़ सकते हैं. इसलिए, हमारे पास यह 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);
}
हम तस्वीर में पहचानी गई चीज़ों, कैटगरी या थीम के लेबल पाने जा रहे हैं:
List<String> labels = response.getLabelAnnotationsList().stream()
.map(annotation -> annotation.getDescription())
.collect(Collectors.toList());
logger.info("Annotations found:");
for (String label: labels) {
logger.info("- " + label);
}
हमें इस तस्वीर का मुख्य रंग जानना है:
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);
}
आइए, देखते हैं कि क्या इस फ़ोटो को दिखाया जा सकता है:
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);
}
हम वयस्क / स्पूफ़ / चिकित्सा / हिंसा / उत्तेजित करने वाली विशेषताओं की जांच कर रहे हैं, ताकि यह पता लगाया जा सके कि वे संभवतः या बहुत ज़्यादा तो नहीं हैं.
अगर सेफ़ सर्च का नतीजा ठीक है, तो हम मेटाडेटा को 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. GraalVM की मदद से ऐप्लिकेशन इमेज बनाना
इस वैकल्पिक चरण में, आपको GraalVM का इस्तेमाल करके JIT based app image और फिर Native Java app image बनाना होगा.
बिल्ड को चलाने के लिए, आपको यह पक्का करना होगा कि आपके पास सही JDK हो. साथ ही, नेटिव-इमेज बिल्डर इंस्टॉल और कॉन्फ़िगर किया गया हो. इसके लिए कई विकल्प उपलब्ध हैं.
To start, GraalVM 22.3.x Community Edition डाउनलोड करें. इसके बाद, GraalVM installation पेज पर दिए गए निर्देशों का पालन करें.
SDKMAN! की मदद से, इस प्रोसेस को बहुत आसान बनाया जा सकता है
SDKman की मदद से सही JDK डिस्ट्रिब्यूशन इंस्टॉल करने के लिए, इंस्टॉल कमांड का इस्तेमाल करें:
sdk install java 17.0.8-graal
SDKman को इस वर्शन का इस्तेमाल करने का निर्देश दें. ऐसा JIT और AOT, दोनों तरह की बिल्ड के लिए करें:
sdk use java 17.0.8-graal
Cloudshell में, अपनी सुविधा के लिए, इन सामान्य निर्देशों का इस्तेमाल करके GraalVM और native-image यूटिलिटी इंस्टॉल की जा सकती है:
# 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)
सबसे पहले, GCP प्रोजेक्ट के एनवायरमेंट वैरिएबल सेट करें:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
इसके बाद, लैब बनाने के लिए उस डायरेक्ट्री पर जाएं जिसमें सेवा मौजूद है:
cd serverless-photosharing-workshop/services/image-analysis/java
JIT ऐप्लिकेशन इमेज बनाएं:
./mvnw package
टर्मिनल में बिल्ड लॉग देखें:
... [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] ------------------------------------------------------------------------
नेटिव(AOT का इस्तेमाल करने वाली) इमेज बनाएं:.
./mvnw native:compile -Pnative
टर्मिनल में बिल्ड लॉग देखें. इसमें नेटिव इमेज के बिल्ड लॉग भी शामिल हैं:
ध्यान दें कि मशीन के हिसाब से, बिल्ड होने में ज़्यादा समय लगता है.
...
[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. कंटेनर इमेज बनाना और उन्हें पब्लिश करना
आइए, कंटेनर इमेज को दो अलग-अलग वर्शन में बनाते हैं: एक को JIT image के तौर पर और दूसरे को Native Java image के तौर पर.
सबसे पहले, GCP प्रोजेक्ट के एनवायरमेंट वैरिएबल सेट करें:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
JIT इमेज बनाएं:.
./mvnw spring-boot:build-image -Pji
टर्मिनल में बिल्ड लॉग देखें:
[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] ------------------------------------------------------------------------
AOT(नेटिव) इमेज बनाएं:.
./mvnw spring-boot:build-image -Pnative
टर्मिनल में बिल्ड लॉग देखें. इसमें नेटिव इमेज के बिल्ड लॉग भी शामिल हैं.
ध्यान दें:
- बिल्ड को पूरा होने में काफ़ी समय लगता है. यह इस बात पर निर्भर करता है कि आपने किस मशीन पर टेस्टिंग की है
- UPX की मदद से इमेज को और कंप्रेस किया जा सकता है. हालांकि, इससे स्टार्टअप की परफ़ॉर्मेंस पर थोड़ा बुरा असर पड़ता है. इसलिए, इस बिल्ड में UPX का इस्तेमाल नहीं किया जाता. यह हमेशा थोड़ा समझौता होता है
... [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] ------------------------------------------------------------------------
पुष्टि करें कि इमेज बन गई हैं:
docker images | grep image-analysis
दोनों इमेज को टैग करें और 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. Cloud Run पर डिप्लॉय करें
सेवा को डिप्लॉय करने में लगने वाला समय.
आपको सेवा को दो बार डिप्लॉय करना होगा. पहली बार, JIT इमेज का इस्तेमाल करके और दूसरी बार, AOT(नेटिव) इमेज का इस्तेमाल करके. दोनों सेवा डिप्लॉयमेंट, तुलना करने के लिए बकेट से एक ही इमेज को एक साथ प्रोसेस करेंगे.
सबसे पहले, 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
जेआईटी इमेज को डिप्लॉय करें और कंसोल में डिप्लॉयमेंट लॉग देखें:
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
नेटिव इमेज को डिप्लॉय करें और कंसोल में डिप्लॉयमेंट लॉग देखें:
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. Eventarc ट्रिगर सेट अप करना
Eventarc, स्टेट में होने वाले बदलावों (इन्हें इवेंट कहा जाता है) के फ़्लो को मैनेज करने के लिए, स्टैंडर्ड समाधान उपलब्ध कराता है. यह समाधान, अलग-अलग माइक्रोसेवाओं के बीच काम करता है. ट्रिगर होने पर, Eventarc इन इवेंट को Pub/Sub सदस्यता के ज़रिए अलग-अलग डेस्टिनेशन (इस दस्तावेज़ में, इवेंट डेस्टिनेशन देखें) पर भेजता है. साथ ही, आपके लिए डिलीवरी, सुरक्षा, अनुमति, निगरानी, और गड़बड़ी ठीक करने की सुविधा को मैनेज करता है.
Eventarc ट्रिगर बनाया जा सकता है, ताकि आपकी Cloud Run सेवा को किसी इवेंट या इवेंट के सेट की सूचनाएं मिलें. ट्रिगर के लिए फ़िल्टर तय करके, इवेंट की राउटिंग को कॉन्फ़िगर किया जा सकता है. इसमें इवेंट सोर्स और टारगेट Cloud Run सेवा शामिल है.
सबसे पहले, 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
Cloud Storage सेवा खाते को pubsub.publisher की अनुमति दें:
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'
इमेज को प्रोसेस करने के लिए, JIT और नेटिव सेवा, दोनों के लिए Eventarc ट्रिगर सेट अप करें:
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
देखें कि दो ट्रिगर बनाए गए हैं:
gcloud eventarc triggers list --location=eu
14. सेवा के वर्शन की जांच करना
सेवाएं डिप्लॉय होने के बाद, Cloud Storage में एक फ़ोटो पोस्ट करें. देखें कि हमारी सेवाएं चालू हुई हैं या नहीं, Vision API क्या जवाब देता है, और Firestore में मेटाडेटा सेव किया गया है या नहीं.
Cloud Storage पर वापस जाएं और उस बकेट पर क्लिक करें जिसे हमने लैब की शुरुआत में बनाया था:
बकेट की जानकारी वाले पेज पर जाकर, फ़ोटो अपलोड करने के लिए Upload files बटन पर क्लिक करें.
उदाहरण के लिए, GeekHour.jpeg इमेज को आपके कोडबेस के साथ /services/image-analysis/java में दिया जाता है. कोई इमेज चुनें और Open button दबाएं:
अब आपको सेवा के लागू होने की जानकारी दिखेगी. इसकी शुरुआत image-analysis-jit से होगी. इसके बाद, image-analysis-native दिखेगा.
"हैमबर्गर" (☰) मेन्यू में जाकर, Cloud Run > image-analysis-jit सेवा पर जाएं.
लॉग पर क्लिक करें और आउटपुट देखें:
मुझे लॉग की सूची में दिख रहा है कि JIT सेवा image-analysis-jit को चालू किया गया था.
लॉग से पता चलता है कि सेवा कब शुरू हुई और कब खत्म हुई. इसके बीच में, हम अपने फ़ंक्शन में डाले गए लॉग देख सकते हैं. इनमें INFO लेवल पर लॉग स्टेटमेंट शामिल हैं. हमें यह जानकारी मिलती है:
- उस इवेंट की जानकारी जिसकी वजह से हमारा फ़ंक्शन ट्रिगर हुआ है,
- Vision API कॉल से मिले रॉ नतीजे,
- अपलोड की गई फ़ोटो में मिले लेबल,
- मुख्य रंगों की जानकारी,
- क्या इस इमेज को दिखाना सुरक्षित है,
- इसके बाद, फ़ोटो के बारे में उस मेटाडेटा को Firestore में सेव कर दिया जाता है.
आपको image-analysis-native सेवा के लिए, यह प्रोसेस फिर से करनी होगी.
"हैमबर्गर" (☰) मेन्यू में जाकर, Cloud Run > image-analysis-native सेवा पर जाएं.
लॉग पर क्लिक करें और आउटपुट देखें:
अब आपको यह देखना होगा कि इमेज का मेटाडेटा, Fiorestore में सेव हुआ है या नहीं.
"हैमबर्गर" (☰) मेन्यू में जाकर, Firestore सेक्शन पर जाएं. Data सब-सेक्शन (डिफ़ॉल्ट रूप से दिखता है) में, आपको pictures कलेक्शन दिखेगा. इसमें अभी अपलोड की गई फ़ोटो से जुड़ा एक नया दस्तावेज़ जोड़ा गया होगा:
15. डेटा साफ़ करना (ज़रूरी नहीं)
अगर आपको सीरीज़ में शामिल अन्य लैब का इस्तेमाल नहीं करना है, तो संसाधनों को बंद करें. इससे लागत कम करने में मदद मिलेगी. साथ ही, यह क्लाउड का इस्तेमाल करने का एक अच्छा तरीका है. यहां दिए गए तरीके से, संसाधनों को अलग-अलग करके हटाया जा सकता है.
बकेट मिटाएं:
gsutil rb gs://${BUCKET_PICTURES}
फ़ंक्शन मिटाएं:
gcloud functions delete picture-uploaded --region europe-west1 -q
संग्रह से, संग्रह मिटाएं को चुनकर Firestore कलेक्शन मिटाएं:
इसके अलावा, पूरे प्रोजेक्ट को मिटाया जा सकता है:
gcloud projects delete ${GOOGLE_CLOUD_PROJECT}
16. बधाई हो!
बधाई हो! आपने प्रोजेक्ट की पहली मुख्य सेवा को लागू कर दिया है!
हमने क्या-क्या बताया
- Cloud Storage
- Cloud Run
- Cloud Vision API
- Cloud Firestore
- नेटिव Java इमेज