1. खास जानकारी
इस कोडलैब में, Google App Engine पर एक वेब फ़्रंटएंड बनाया जाता है. इससे उपयोगकर्ता, वेब ऐप्लिकेशन से तस्वीरें अपलोड कर पाएंगे. साथ ही, अपलोड की गई तस्वीरें और उनके थंबनेल ब्राउज़ कर पाएंगे.

यह वेब ऐप्लिकेशन, Bulma नाम के सीएसएस फ़्रेमवर्क का इस्तेमाल करेगा, ताकि यूज़र इंटरफ़ेस अच्छा दिखे. साथ ही, यह Vue.JS JavaScript फ़्रंटएंड फ़्रेमवर्क का इस्तेमाल करेगा, ताकि आपके बनाए गए ऐप्लिकेशन के एपीआई को कॉल किया जा सके.
इस ऐप्लिकेशन में तीन टैब होंगे:
- एक होम पेज, जिस पर अपलोड की गई सभी इमेज के थंबनेल दिखेंगे. साथ ही, इमेज के बारे में बताने वाले लेबल की सूची भी दिखेगी. ये लेबल, पिछली लैब में Cloud Vision API ने पहचाने थे.
- कोलाज पेज, जिस पर अपलोड की गई चार सबसे नई फ़ोटो से बना कोलाज दिखेगा.
- अपलोड पेज, जहां उपयोगकर्ता नई तस्वीरें अपलोड कर सकते हैं.
नतीजे के तौर पर मिलने वाला फ़्रंटएंड इस तरह दिखता है:

ये तीनों पेज, सामान्य एचटीएमएल पेज हैं:
- होम पेज (
index.html), Node App Engine के बैकएंड कोड को कॉल करता है, ताकि थंबनेल की तस्वीरों और उनके लेबल की सूची मिल सके. इसके लिए,/api/picturesयूआरएल पर AJAX कॉल किया जाता है. होम पेज, इस डेटा को फ़ेच करने के लिए Vue.js का इस्तेमाल कर रहा है. - कोलाज पेज (
collage.html)collage.pngइमेज पर ले जाता है. इसमें चार नई फ़ोटो शामिल हैं. - अपलोड पेज (
upload.html) पर एक आसान फ़ॉर्म मौजूद है. इसकी मदद से,/api/picturesयूआरएल पर पोस्ट अनुरोध भेजकर, फ़ोटो अपलोड की जा सकती है.
आपको क्या सीखने को मिलेगा
- App Engine
- Cloud Storage
- Cloud Firestore
2. सेटअप और ज़रूरी शर्तें
अपनी रफ़्तार से एनवायरमेंट सेटअप करना
- Google Cloud Console में साइन-इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.



- प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे किसी भी समय अपडेट किया जा सकता है.
- प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होना चाहिए. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, अपने-आप एक यूनीक स्ट्रिंग जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको प्रोजेक्ट आईडी का रेफ़रंस देना होगा. आम तौर पर, इसकी पहचान
PROJECT_IDके तौर पर की जाती है. इसलिए, अगर आपको यह पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट करें. इसके अलावा, आपके पास खुद का आईडी जनरेट करने और यह देखने का विकल्प भी है कि वह उपलब्ध है या नहीं. प्रोजेक्ट बनाने के बाद, इसे "फ़्रीज़" कर दिया जाता है. - तीसरी वैल्यू, प्रोजेक्ट नंबर है. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ पढ़ें.
- इसके बाद, आपको Cloud के संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करनी होगी. इस कोडलैब को पूरा करने में आपको ज़्यादा खर्च नहीं करना पड़ेगा. संसाधनों को बंद करने के लिए, कोडलैब के आखिर में दिए गए "क्लीन-अप" निर्देशों का पालन करें. इससे, इस ट्यूटोरियल के अलावा आपसे कोई और शुल्क नहीं लिया जाएगा. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त क्रेडिट वाले प्रोग्राम में शामिल हो सकते हैं.
Cloud Shell को चालू करना
Google Cloud को आपके लैपटॉप से रिमोटली ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में आपको Google Cloud Shell का इस्तेमाल करना होगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Google Cloud Console में जाकर, सबसे ऊपर दाईं ओर मौजूद टूलबार में Cloud Shell आइकॉन पर क्लिक करें:

एनवायरमेंट को सेट अप करने और उससे कनेक्ट होने में कुछ ही समय लगना चाहिए. इंस्टॉल होने के बाद, आपको कुछ ऐसा दिखेगा:

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, यह Google Cloud पर चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस लैब में मौजूद सभी टास्क, सिर्फ़ ब्राउज़र का इस्तेमाल करके पूरे किए जा सकते हैं.
3. एपीआई चालू करें
App Engine के लिए, Compute Engine API ज़रूरी है. पक्का करें कि यह चालू हो:
gcloud services enable compute.googleapis.com
आपको कार्रवाई पूरी होने का मैसेज दिखेगा:
Operation "operations/acf.5c5ef4f6-f734-455d-b2f0-ee70b5a17322" finished successfully.
4. कोड को क्लोन करें
अगर आपने अब तक कोड नहीं देखा है, तो यहां देखें:
git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop
इसके बाद, फ़्रंटएंड वाली डायरेक्ट्री पर जाएं:
cd serverless-photosharing-workshop/frontend
फ़्रंटएंड के लिए, आपके पास यह फ़ाइल लेआउट होगा:
frontend
|
├── index.js
├── package.json
├── app.yaml
|
├── public
|
├── index.html
├── collage.html
├── upload.html
|
├── app.js
├── script.js
├── style.css
हमारे प्रोजेक्ट की रूट डायरेक्ट्री में तीन फ़ाइलें हैं:
index.jsमें Node.js कोड होता हैpackage.jsonलाइब्रेरी की डिपेंडेंसी तय करता हैapp.yaml, Google App Engine के लिए कॉन्फ़िगरेशन फ़ाइल है
public फ़ोल्डर में स्टैटिक रिसॉर्स होते हैं:
index.htmlवह पेज है जिस पर सभी थंबनेल इमेज और लेबल दिखते हैंcollage.html, हाल ही की फ़ोटो का कोलाज दिखाता हैupload.htmlमें नई फ़ोटो अपलोड करने के लिए एक फ़ॉर्म हैapp.js,index.htmlपेज पर डेटा भरने के लिए Vue.js का इस्तेमाल कर रहा हैscript.js, छोटी स्क्रीन पर नेविगेशन मेन्यू और उसके "हैमबर्गर" आइकॉन को मैनेज करता हैstyle.cssमें कुछ सीएसएस डायरेक्टिव तय किए गए हैं
5. कोड एक्सप्लोर करना
डिपेंडेंसी
package.json फ़ाइल में, लाइब्रेरी की ज़रूरी डिपेंडेंसी के बारे में बताया गया है:
{
"name": "frontend",
"version": "0.0.1",
"main": "index.js",
"scripts": {
"start": "node index.js"
},
"dependencies": {
"@google-cloud/firestore": "^3.4.1",
"@google-cloud/storage": "^4.0.0",
"express": "^4.16.4",
"dayjs": "^1.8.22",
"bluebird": "^3.5.0",
"express-fileupload": "^1.1.6"
}
}
हमारा ऐप्लिकेशन इन पर निर्भर करता है:
- firestore: हमारी इमेज के मेटाडेटा के साथ Cloud Firestore को ऐक्सेस करने के लिए,
- स्टोरेज: Google Cloud Storage को ऐक्सेस करने के लिए, जहां फ़ोटो सेव की जाती हैं,
- express: Node.js के लिए वेब फ़्रेमवर्क,
- dayjs: यह एक छोटी लाइब्रेरी है, जो तारीखों को आसान तरीके से दिखाती है,
- bluebird: JavaScript प्रॉमिस लाइब्रेरी,
- express-fileupload: यह एक लाइब्रेरी है, जिससे फ़ाइलें आसानी से अपलोड की जा सकती हैं.
एक्सप्रेस फ़्रंटएंड
index.js कंट्रोलर की शुरुआत में, आपको package.json में पहले से तय की गई सभी डिपेंडेंसी की ज़रूरत होगी:
const express = require('express');
const fileUpload = require('express-fileupload');
const Firestore = require('@google-cloud/firestore');
const Promise = require("bluebird");
const {Storage} = require('@google-cloud/storage');
const storage = new Storage();
const path = require('path');
const dayjs = require('dayjs');
const relativeTime = require('dayjs/plugin/relativeTime')
dayjs.extend(relativeTime)
इसके बाद, Express ऐप्लिकेशन इंस्टेंस बनाया जाता है.
दो Express मिडलवेयर इस्तेमाल किए जाते हैं:
express.static()कॉल से पता चलता है कि स्टैटिक रिसॉर्स,publicसब-डायरेक्ट्री में उपलब्ध होंगे.- साथ ही,
fileUpload(), फ़ाइल अपलोड करने की सुविधा को कॉन्फ़िगर करता है, ताकि फ़ाइल का साइज़ 10 एमबी तक सीमित किया जा सके. इससे फ़ाइलों को/tmpडायरेक्ट्री में, इन-मेमोरी फ़ाइल सिस्टम में स्थानीय तौर पर अपलोड किया जा सकता है.
const app = express();
app.use(express.static('public'));
app.use(fileUpload({
limits: { fileSize: 10 * 1024 * 1024 },
useTempFiles : true,
tempFileDir : '/tmp/'
}))
स्टैटिक रिसॉर्स में, होम पेज, कोलाज पेज, और अपलोड पेज के लिए एचटीएमएल फ़ाइलें शामिल हैं. ये पेज, एपीआई बैकएंड को कॉल करेंगे. इस एपीआई में ये एंडपॉइंट होंगे:
POST /api/picturesupload.html में मौजूद फ़ॉर्म के ज़रिए, पोस्ट अनुरोध का इस्तेमाल करके तस्वीरें अपलोड की जाएंगीGET /api/picturesयह एंडपॉइंट, JSON फ़ॉर्मैट में एक दस्तावेज़ दिखाता है. इसमें इमेज और उनके लेबल की सूची होती हैGET /api/pictures/:nameयह यूआरएल, क्लाउड स्टोरेज में मौजूद फ़ुल-साइज़ इमेज पर रीडायरेक्ट करता हैGET /api/thumbnails/:nameयह यूआरएल, थंबनेल इमेज के क्लाउड स्टोरेज की जगह पर रीडायरेक्ट करता हैGET /api/collageयह आखिरी यूआरएल, जनरेट की गई कोलाज इमेज के क्लाउड स्टोरेज की जगह पर रीडायरेक्ट करता है
इमेज अपलोड करना
इमेज अपलोड करने के लिए Node.js कोड को एक्सप्लोर करने से पहले, public/upload.html पर एक नज़र डालें.
...
<form method="POST" action="/api/pictures" enctype="multipart/form-data">
...
<input type="file" name="pictures">
<button>Submit</button>
...
</form>
...
फ़ॉर्म एलिमेंट, एचटीटीपी पोस्ट तरीके और मल्टी-पार्ट फ़ॉर्मैट के साथ /api/pictures एंडपॉइंट पर ले जाता है. अब index.js को उस एंडपॉइंट और तरीके का जवाब देना होगा और फ़ाइलें निकालनी होंगी:
app.post('/api/pictures', async (req, res) => {
if (!req.files || Object.keys(req.files).length === 0) {
console.log("No file uploaded");
return res.status(400).send('No file was uploaded.');
}
console.log(`Receiving files ${JSON.stringify(req.files.pictures)}`);
const pics = Array.isArray(req.files.pictures) ? req.files.pictures : [req.files.pictures];
pics.forEach(async (pic) => {
console.log('Storing file', pic.name);
const newPicture = path.resolve('/tmp', pic.name);
await pic.mv(newPicture);
const pictureBucket = storage.bucket(process.env.BUCKET_PICTURES);
await pictureBucket.upload(newPicture, { resumable: false });
});
res.redirect('/');
});
सबसे पहले, यह देखें कि फ़ाइलें अपलोड हो रही हैं या नहीं. इसके बाद, फ़ाइल अपलोड करने वाले हमारे Node मॉड्यूल से मिलने वाले mv तरीके का इस्तेमाल करके, फ़ाइलों को स्थानीय तौर पर डाउनलोड किया जाता है. अब फ़ाइलें लोकल फ़ाइल सिस्टम पर उपलब्ध हैं. इसलिए, तस्वीरों को Cloud Storage बकेट में अपलोड करें. आखिर में, उपयोगकर्ता को ऐप्लिकेशन की मुख्य स्क्रीन पर वापस रीडायरेक्ट करें.
तस्वीरों की सूची बनाना
अब बारी है अपनी खूबसूरत तस्वीरें दिखाने की!
/api/pictures हैंडलर में, Firestore डेटाबेस के pictures कलेक्शन को देखें. इससे आपको उन सभी फ़ोटो की जानकारी मिलेगी जिनके थंबनेल जनरेट किए गए हैं. ये फ़ोटो, बनाए जाने की तारीख के हिसाब से घटते क्रम में दिखेंगी.
आप हर तस्वीर को JavaScript कलेक्शन में पुश करते हैं. इसमें तस्वीर का नाम, उसके बारे में बताने वाले लेबल (Cloud Vision API से मिले), मुख्य रंग, और बनाने की तारीख (dayjs के साथ, हम "आज से तीन दिन बाद" जैसे रिलेटिव टाइम ऑफ़सेट) शामिल होते हैं.
app.get('/api/pictures', async (req, res) => {
console.log('Retrieving list of pictures');
const thumbnails = [];
const pictureStore = new Firestore().collection('pictures');
const snapshot = await pictureStore
.where('thumbnail', '==', true)
.orderBy('created', 'desc').get();
if (snapshot.empty) {
console.log('No pictures found');
} else {
snapshot.forEach(doc => {
const pic = doc.data();
thumbnails.push({
name: doc.id,
labels: pic.labels,
color: pic.color,
created: dayjs(pic.created.toDate()).fromNow()
});
});
}
console.table(thumbnails);
res.send(thumbnails);
});
यह कंट्रोलर, इस तरह के नतीजे दिखाता है:
[
{
"name": "IMG_20180423_163745.jpg",
"labels": [
"Dish",
"Food",
"Cuisine",
"Ingredient",
"Orange chicken",
"Produce",
"Meat",
"Staple food"
],
"color": "#e78012",
"created": "a day ago"
},
...
]
इस डेटा स्ट्रक्चर का इस्तेमाल, index.html पेज के Vue.js स्निपेट से किया जाता है. यहां उस पेज के मार्कअप का आसान वर्शन दिया गया है:
<div id="app">
<div class="container" id="app">
<div id="picture-grid">
<div class="card" v-for="pic in pictures">
<div class="card-content">
<div class="content">
<div class="image-border" :style="{ 'border-color': pic.color }">
<a :href="'/api/pictures/' + pic.name">
<img :src="'/api/thumbnails/' + pic.name">
</a>
</div>
<a class="panel-block" v-for="label in pic.labels" :href="'/?q=' + label">
<span class="panel-icon">
<i class="fas fa-bookmark"></i>
</span>
{{ label }}
</a>
</div>
</div>
</div>
</div>
</div>
</div>
div का आईडी, Vue.js को बताएगा कि यह मार्कअप का वह हिस्सा है जिसे डाइनैमिक तौर पर रेंडर किया जाएगा. v-for डायरेक्टिव की मदद से, बार-बार बदलाव किए जाते हैं.
इमेज में मौजूद मुख्य रंग के हिसाब से, इमेज को एक अच्छा रंगीन बॉर्डर मिलता है. यह रंग, Cloud Vision API से पता चलता है. साथ ही, हम लिंक और इमेज सोर्स में थंबनेल और फ़ुल-विड्थ वाली इमेज पर ले जाते हैं.
आखिर में, हम इमेज के बारे में बताने वाले लेबल की सूची बनाते हैं.
यहां Vue.js स्निपेट के लिए JavaScript कोड दिया गया है. यह कोड, index.html पेज के सबसे नीचे इंपोर्ट की गई public/app.js फ़ाइल में मौजूद है:
var app = new Vue({
el: '#app',
data() {
return { pictures: [] }
},
mounted() {
axios
.get('/api/pictures')
.then(response => { this.pictures = response.data })
}
})
Vue कोड, हमारे /api/pictures एंडपॉइंट पर AJAX कॉल करने के लिए, Axios लाइब्रेरी का इस्तेमाल कर रहा है. इसके बाद, वापस मिले डेटा को मार्कअप में व्यू कोड से बाइंड किया जाता है, जैसा कि आपने पहले देखा था.
तस्वीरें देखना
index.html से, हमारे उपयोगकर्ता फ़ोटो के थंबनेल देख सकते हैं. साथ ही, उन पर क्लिक करके फ़ोटो को फ़ुल-साइज़ में देख सकते हैं. इसके अलावा, collage.html से उपयोगकर्ता collage.png इमेज देख सकते हैं.
उन पेजों के एचटीएमएल मार्कअप में, इमेज src और लिंक href उन तीन एंडपॉइंट पर ले जाते हैं जो तस्वीरों, थंबनेल, और कोलाज के Cloud Storage की जगहों पर रीडायरेक्ट करते हैं. एचटीएमएल मार्कअप में पाथ को हार्ड-कोड करने की ज़रूरत नहीं है.
app.get('/api/pictures/:name', async (req, res) => {
res.redirect(`https://storage.cloud.google.com/${process.env.BUCKET_PICTURES}/${req.params.name}`);
});
app.get('/api/thumbnails/:name', async (req, res) => {
res.redirect(`https://storage.cloud.google.com/${process.env.BUCKET_THUMBNAILS}/${req.params.name}`);
});
app.get('/api/collage', async (req, res) => {
res.redirect(`https://storage.cloud.google.com/${process.env.BUCKET_THUMBNAILS}/collage.png`);
});
Node ऐप्लिकेशन चलाना
सभी एंडपॉइंट तय होने के बाद, आपका Node.js ऐप्लिकेशन लॉन्च होने के लिए तैयार है. Express ऐप्लिकेशन, डिफ़ॉल्ट रूप से पोर्ट 8080 पर सिग्नल पाने के लिए कॉन्फ़िगर किया गया है. साथ ही, यह आने वाले अनुरोधों को पूरा करने के लिए तैयार है.
const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
console.log(`Started web frontend service on port ${PORT}`);
console.log(`- Pictures bucket = ${process.env.BUCKET_PICTURES}`);
console.log(`- Thumbnails bucket = ${process.env.BUCKET_THUMBNAILS}`);
});
6. लोकल तौर पर टेस्ट करना
कोड को क्लाउड पर डिप्लॉय करने से पहले, उसे अपने डिवाइस पर टेस्ट करें. इससे यह पक्का किया जा सकेगा कि कोड सही तरीके से काम कर रहा है.
आपको दो Cloud Storage बकेट के लिए, दो एनवायरमेंट वैरिएबल एक्सपोर्ट करने होंगे:
export BUCKET_THUMBNAILS=thumbnails-${GOOGLE_CLOUD_PROJECT}
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
frontend फ़ोल्डर में, npm डिपेंडेंसी इंस्टॉल करें और सर्वर चालू करें:
npm install; npm start
अगर सब कुछ ठीक रहा, तो सर्वर को पोर्ट 8080 पर शुरू हो जाना चाहिए:
Started web frontend service on port 8080
- Pictures bucket = uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
- Thumbnails bucket = thumbnails-${GOOGLE_CLOUD_PROJECT}
उन लॉग में आपकी बकेट के असली नाम दिखेंगे. इससे डीबग करने में मदद मिलती है.
Cloud Shell से, वेब की सिर्फ़ झलक के लिए उपलब्ध सुविधा का इस्तेमाल करके, स्थानीय तौर पर चल रहे ऐप्लिकेशन को ब्राउज़ किया जा सकता है:

बाहर निकलने के लिए, CTRL-C का इस्तेमाल करें.
7. App Engine पर डिप्लॉय करना
आपका ऐप्लिकेशन डिप्लॉय होने के लिए तैयार है.
App Engine को कॉन्फ़िगर करना
App Engine के लिए, app.yaml कॉन्फ़िगरेशन फ़ाइल की जांच करें:
runtime: nodejs16 env_variables: BUCKET_PICTURES: uploaded-pictures-GOOGLE_CLOUD_PROJECT BUCKET_THUMBNAILS: thumbnails-GOOGLE_CLOUD_PROJECT
पहली लाइन से पता चलता है कि रनटाइम, Node.js 10 पर आधारित है. ओरिजनल इमेज और थंबनेल के लिए, दो बकेट को पॉइंट करने के लिए दो एनवायरमेंट वैरिएबल तय किए गए हैं.
GOOGLE_CLOUD_PROJECT को अपने असल प्रोजेक्ट आईडी से बदलने के लिए, यह कमांड चलाएं:
sed -i -e "s/GOOGLE_CLOUD_PROJECT/${GOOGLE_CLOUD_PROJECT}/" app.yaml
डिप्लॉय करना
App Engine के लिए अपनी पसंद का क्षेत्र सेट करें. पक्का करें कि आपने पिछली लैब में भी उसी क्षेत्र का इस्तेमाल किया हो:
gcloud config set compute/region europe-west1
और डिप्लॉय करें:
gcloud app deploy
एक या दो मिनट के बाद, आपको बताया जाएगा कि ऐप्लिकेशन पर ट्रैफ़िक आ रहा है:
Beginning deployment of service [default]... ╔════════════════════════════════════════════════════════════╗ ╠═ Uploading 8 files to Google Cloud Storage ═╣ ╚════════════════════════════════════════════════════════════╝ File upload done. Updating service [default]...done. Setting traffic split for service [default]...done. Deployed service [default] to [https://GOOGLE_CLOUD_PROJECT.appspot.com] You can stream logs from the command line by running: $ gcloud app logs tail -s default To view your application in the web browser run: $ gcloud app browse
Cloud Console के App Engine सेक्शन में जाकर भी यह देखा जा सकता है कि ऐप्लिकेशन डिप्लॉय हो गया है. साथ ही, App Engine की सुविधाओं को एक्सप्लोर किया जा सकता है. जैसे, वर्शन बनाना और ट्रैफ़िक को बांटना:

8. ऐप्लिकेशन को टेस्ट करना
जांच करने के लिए, ऐप्लिकेशन के डिफ़ॉल्ट App Engine यूआरएल (https://<YOUR_PROJECT_ID>.appspot.com/) पर जाएं. आपको फ़्रंटएंड यूज़र इंटरफ़ेस (यूआई) दिखेगा और वह काम कर रहा होगा!

9. क्लीन अप (ज़रूरी नहीं)
अगर आपको ऐप्लिकेशन नहीं रखना है, तो पूरे प्रोजेक्ट को मिटाकर संसाधनों को खाली किया जा सकता है. इससे लागत कम होगी और क्लाउड का बेहतर इस्तेमाल किया जा सकेगा:
gcloud projects delete ${GOOGLE_CLOUD_PROJECT}
10. बधाई हो!
बधाई हो! App Engine पर होस्ट किया गया यह Node.js वेब ऐप्लिकेशन, आपकी सभी सेवाओं को एक साथ जोड़ता है. साथ ही, आपके उपयोगकर्ताओं को तस्वीरें अपलोड करने और उन्हें देखने की सुविधा देता है.
हमने क्या-क्या कवर किया
- App Engine
- Cloud Storage
- Cloud Firestore