1. Übersicht
In diesem Codelab erstellen Sie ein Web-Frontend in Google App Engine, mit dem Nutzer Bilder aus der Webanwendung hochladen und die hochgeladenen Bilder und Miniaturansichten durchsuchen können.

Diese Webanwendung verwendet ein CSS-Framework namens Bulma, um eine ansprechende Benutzeroberfläche zu erstellen, sowie das JavaScript-Frontend-Framework Vue.JS, um die API der Anwendung aufzurufen, die Sie erstellen werden.
Diese Anwendung besteht aus drei Tabs:
- Eine Startseite, auf der die Miniaturansichten aller hochgeladenen Bilder zusammen mit der Liste der Labels angezeigt werden, die das Bild beschreiben (die in einem vorherigen Lab von der Cloud Vision API erkannt wurden).
- Eine Collage-Seite, auf der die Collage aus den vier zuletzt hochgeladenen Bildern angezeigt wird.
- Eine Upload-Seite, auf der Nutzer neue Bilder hochladen können.
Das resultierende Frontend sieht so aus:

Diese drei Seiten sind einfache HTML-Seiten:
- Die Startseite (
index.html) ruft den Node App Engine-Backend-Code auf, um die Liste der Miniaturansichten und ihrer Labels über einen AJAX-Aufruf an die URL/api/picturesabzurufen. Auf der Startseite wird Vue.js verwendet, um diese Daten abzurufen. - Die Seite collage (
collage.html) verweist auf das Bildcollage.png, das die vier neuesten Bilder enthält. - Die Seite upload (
upload.html) bietet ein einfaches Formular zum Hochladen eines Bildes über eine POST-Anfrage an die URL/api/pictures.
Lerninhalte
- App Engine
- Cloud Storage
- Cloud Firestore
2. Einrichtung und Anforderungen
Umgebung zum selbstbestimmten Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.



- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird und den Sie jederzeit aktualisieren können.
- Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). Die Cloud Console generiert automatisch einen eindeutigen String. In der Regel ist es egal, wie dieser lautet. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (die normalerweise als
PROJECT_IDbezeichnet wird). Wenn Ihnen die ID nicht gefällt, können Sie eine andere zufällige ID generieren oder eine eigene ID ausprobieren, um zu sehen, ob sie verfügbar ist. Nachdem das Projekt erstellt wurde, wird sie „eingefroren“. - Es gibt einen dritten Wert, eine Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen und ‑APIs verwenden zu können. Die Ausführung dieses Codelabs sollte, wenn überhaupt, nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit Ihnen über diese Anleitung hinaus keine Kosten entstehen, folgen Sie der Anleitung zum Bereinigen am Ende des Codelabs. Neue Nutzer von Google Cloud können am kostenlosen Testprogramm mit einem Guthaben von 300 $ teilnehmen.
Cloud Shell starten
Google Cloud kann zwar remote von Ihrem Laptop aus bedient werden, in diesem Codelab verwenden Sie jedoch die Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Wenn der Vorgang abgeschlossen ist, wird in etwa Folgendes angezeigt:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Für alle Aufgaben in diesem Lab benötigen Sie lediglich einen Browser.
3. APIs aktivieren
Für App Engine ist die Compute Engine API erforderlich. Achten Sie darauf, dass sie aktiviert ist:
gcloud services enable compute.googleapis.com
Der Vorgang sollte erfolgreich abgeschlossen werden:
Operation "operations/acf.5c5ef4f6-f734-455d-b2f0-ee70b5a17322" finished successfully.
4. Code klonen
Checken Sie den Code aus, falls noch nicht geschehen:
git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop
Wechseln Sie dann in das Verzeichnis mit dem Frontend:
cd serverless-photosharing-workshop/frontend
Für das Frontend gilt das folgende Dateilayout:
frontend
|
├── index.js
├── package.json
├── app.yaml
|
├── public
|
├── index.html
├── collage.html
├── upload.html
|
├── app.js
├── script.js
├── style.css
Im Stammverzeichnis unseres Projekts befinden sich drei Dateien:
index.jsenthält den Node.js-Codepackage.jsondefiniert die Bibliotheksabhängigkeiten.app.yamlist die Konfigurationsdatei für Google App Engine.
Ein public-Ordner enthält die statischen Ressourcen:
index.htmlist die Seite, auf der alle Miniaturansichten und Labels angezeigt werden.collage.htmlzeigt die Collage mit den aktuellen Bildernupload.htmlenthält ein Formular zum Hochladen neuer Bilder.app.jsverwendet Vue.js, um die Seiteindex.htmlmit den Daten zu füllen.script.jsverarbeitet das Navigationsmenü und das Dreistrich-Menüsymbol auf kleinen Bildschirmen.style.cssdefiniert einige CSS-Anweisungen
5. Code ansehen
Abhängigkeiten
In der Datei package.json werden die erforderlichen Bibliotheksabhängigkeiten definiert:
{
"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"
}
}
Unsere Anwendung ist abhängig von:
- firestore: für den Zugriff auf Cloud Firestore mit unseren Bildmetadaten
- storage: für den Zugriff auf Google Cloud Storage, wo Bilder gespeichert werden,
- express: das Web-Framework für Node.js,
- dayjs: eine kleine Bibliothek, um Datumsangaben nutzerfreundlich darzustellen,
- bluebird: eine JavaScript-Promise-Bibliothek,
- express-fileupload: Eine Bibliothek, mit der sich Dateiuploads einfach verarbeiten lassen.
Express-Frontend
Am Anfang des index.js-Controllers benötigen Sie alle zuvor in package.json definierten Abhängigkeiten:
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)
Als Nächstes wird die Express-Anwendungsinstanz erstellt.
Es werden zwei Express-Middlewares verwendet:
- Der Aufruf
express.static()gibt an, dass statische Ressourcen im Unterverzeichnispublicverfügbar sind. - Mit
fileUpload()wird der Dateiupload so konfiguriert, dass die Dateigröße auf 10 MB begrenzt ist. Die Dateien werden lokal im speicherinternen Dateisystem im Verzeichnis/tmphochgeladen.
const app = express();
app.use(express.static('public'));
app.use(fileUpload({
limits: { fileSize: 10 * 1024 * 1024 },
useTempFiles : true,
tempFileDir : '/tmp/'
}))
Zu den statischen Ressourcen gehören die HTML-Dateien für die Startseite, die Collagen-Seite und die Upload-Seite. Diese Seiten rufen das API-Backend auf. Diese API hat die folgenden Endpunkte:
POST /api/picturesÜber das Formular in upload.html werden Bilder über eine POST-Anfrage hochgeladenGET /api/picturesDieser Endpunkt gibt ein JSON-Dokument mit der Liste der Bilder und ihrer Labels zurück.GET /api/pictures/:nameDiese URL leitet zum Cloud Storage-Speicherort des Bildes in voller Größe weiter.GET /api/thumbnails/:nameDiese URL leitet zum Cloud Storage-Speicherort des Miniaturbilds weiter.GET /api/collageDiese letzte URL leitet zum Cloud Storage-Speicherort des generierten Collage-Bildes weiter.
Bild hochladen
Bevor Sie sich den Node.js-Code für den Bildupload ansehen, werfen Sie einen kurzen Blick auf public/upload.html.
...
<form method="POST" action="/api/pictures" enctype="multipart/form-data">
...
<input type="file" name="pictures">
<button>Submit</button>
...
</form>
...
Das Formularelement verweist auf den Endpunkt /api/pictures mit einer HTTP-POST-Methode und einem mehrteiligen Format. Der index.js muss jetzt auf diesen Endpunkt und diese Methode reagieren und die Dateien extrahieren:
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('/');
});
Zuerst prüfen Sie, ob tatsächlich Dateien hochgeladen werden. Anschließend laden Sie die Dateien lokal über die Methode mv aus dem Node-Modul für den Dateiupload herunter. Da die Dateien jetzt im lokalen Dateisystem verfügbar sind, können Sie die Bilder in den Cloud Storage-Bucket hochladen. Schließlich leiten Sie den Nutzer zurück zum Hauptbildschirm der Anwendung.
Bilder auflisten
Zeit, deine schönen Bilder zu präsentieren!
Im Handler /api/pictures suchen Sie in der Sammlung pictures der Firestore-Datenbank nach allen Bildern (deren Miniaturansicht generiert wurde), sortiert nach absteigendem Erstellungsdatum.
Sie fügen jedes Bild in ein JavaScript-Array ein, mit seinem Namen, den beschreibenden Labels (aus der Cloud Vision API), der dominanten Farbe und einem benutzerfreundlichen Erstellungsdatum (mit dayjs verwenden wir relative zeitliche Versätze wie „in 3 Tagen“).
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);
});
Dieser Controller gibt Ergebnisse in der folgenden Form zurück:
[
{
"name": "IMG_20180423_163745.jpg",
"labels": [
"Dish",
"Food",
"Cuisine",
"Ingredient",
"Orange chicken",
"Produce",
"Meat",
"Staple food"
],
"color": "#e78012",
"created": "a day ago"
},
...
]
Diese Datenstruktur wird von einem kleinen Vue.js-Snippet auf der Seite index.html verwendet. Hier ist eine vereinfachte Version des Markups dieser Seite:
<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>
Die ID des div-Elements zeigt Vue.js an, dass es sich um den Teil des Markups handelt, der dynamisch gerendert wird. Die Iterationen werden dank der v-for-Anweisungen ausgeführt.
Die Bilder erhalten einen farbigen Rahmen, der der dominanten Farbe im Bild entspricht, die von der Cloud Vision API ermittelt wurde. Wir verweisen in den Link- und Bildquellen auf die Miniaturansichten und die Bilder in voller Breite.
Zuletzt listen wir die Labels auf, die das Bild beschreiben.
Hier ist der JavaScript-Code für das Vue.js-Snippet (in der Datei public/app.js, die unten auf der Seite index.html importiert wird):
var app = new Vue({
el: '#app',
data() {
return { pictures: [] }
},
mounted() {
axios
.get('/api/pictures')
.then(response => { this.pictures = response.data })
}
})
Der Vue-Code verwendet die Axios-Bibliothek, um einen AJAX-Aufruf an den /api/pictures-Endpunkt zu senden. Die zurückgegebenen Daten werden dann an den Ansichtscode im Markup gebunden, das Sie zuvor gesehen haben.
Bilder ansehen
In der index.html können unsere Nutzer die Miniaturansichten der Bilder sehen und darauf klicken, um die Bilder in voller Größe anzusehen. In der collage.html sehen die Nutzer das collage.png Bild.
Im HTML-Markup dieser Seiten verweisen das Bild src und der Link href auf diese drei Endpunkte, die zu den Cloud Storage-Speicherorten der Bilder, Miniaturansichten und der Collage weiterleiten. Der Pfad muss nicht im HTML-Markup hartcodiert werden.
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-Anwendung ausführen
Nachdem alle Endpunkte definiert sind, kann Ihre Node.js-Anwendung gestartet werden. Die Express-Anwendung überwacht standardmäßig Port 8080 und ist bereit, eingehende Anfragen zu verarbeiten.
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. Lokal testen
Testen Sie den Code lokal, um sicherzustellen, dass er funktioniert, bevor Sie ihn in der Cloud bereitstellen.
Sie müssen die beiden Umgebungsvariablen exportieren, die den beiden Cloud Storage-Buckets entsprechen:
export BUCKET_THUMBNAILS=thumbnails-${GOOGLE_CLOUD_PROJECT}
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
Installieren Sie im Ordner frontend die npm-Abhängigkeiten und starten Sie den Server:
npm install; npm start
Wenn alles geklappt hat, sollte der Server auf Port 8080 gestartet werden:
Started web frontend service on port 8080
- Pictures bucket = uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
- Thumbnails bucket = thumbnails-${GOOGLE_CLOUD_PROJECT}
In diesen Logs werden die tatsächlichen Namen Ihrer Buckets angezeigt, was für die Fehlerbehebung hilfreich ist.
In Cloud Shell können Sie die Webvorschau verwenden, um die lokal ausgeführte Anwendung im Browser aufzurufen:

Verwende zum Beenden CTRL-C.
7. Auf der App Engine bereitstellen
Ihre Anwendung kann jetzt bereitgestellt werden.
App Engine konfigurieren
Sehen Sie sich die Konfigurationsdatei app.yaml für App Engine an:
runtime: nodejs16 env_variables: BUCKET_PICTURES: uploaded-pictures-GOOGLE_CLOUD_PROJECT BUCKET_THUMBNAILS: thumbnails-GOOGLE_CLOUD_PROJECT
In der ersten Zeile wird deklariert, dass die Laufzeit auf Node.js 10 basiert. Es werden zwei Umgebungsvariablen definiert, die auf die beiden Buckets verweisen, einen für die Originalbilder und einen für die Miniaturansichten.
Ersetzen Sie GOOGLE_CLOUD_PROJECT durch Ihre tatsächliche Projekt-ID. Führen Sie dazu den folgenden Befehl aus:
sed -i -e "s/GOOGLE_CLOUD_PROJECT/${GOOGLE_CLOUD_PROJECT}/" app.yaml
Bereitstellen
Legen Sie die bevorzugte Region für App Engine fest. Verwenden Sie dabei dieselbe Region wie in den vorherigen Labs:
gcloud config set compute/region europe-west1
Und bereitstellen:
gcloud app deploy
Nach ein oder zwei Minuten wird Ihnen mitgeteilt, dass die Anwendung Traffic verarbeitet:
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
Sie können auch den App Engine-Bereich der Cloud Console aufrufen, um zu sehen, dass die Anwendung bereitgestellt wurde, und um App Engine-Funktionen wie Versionsverwaltung und Aufteilung des Traffics zu erkunden:

8. Anwendung testen
Rufen Sie zum Testen die Standard-App Engine-URL für die Anwendung (https://<YOUR_PROJECT_ID>.appspot.com/) auf. Die Frontend-UI sollte jetzt ausgeführt werden.

9. Bereinigen (optional)
Wenn Sie die Anwendung nicht behalten möchten, können Sie Ressourcen bereinigen, um Kosten zu sparen und nicht mehr benötigte Ressourcen für andere freizugeben, indem Sie das gesamte Projekt löschen:
gcloud projects delete ${GOOGLE_CLOUD_PROJECT}
10. Glückwunsch!
Glückwunsch! Diese in App Engine gehostete Node.js-Webanwendung verbindet alle Ihre Dienste und ermöglicht es Ihren Nutzern, Bilder hochzuladen und zu visualisieren.
Behandelte Themen
- App Engine
- Cloud Storage
- Cloud Firestore