Pic-a-daily: Lab 4 – Web-Front-End erstellen

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.

21741cd63b425aeb.png

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:

6a4d5e5603ba4b73.png

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/pictures abzurufen. Auf der Startseite wird Vue.js verwendet, um diese Daten abzurufen.
  • Die Seite collage (collage.html) verweist auf das Bild collage.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

  1. 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.

b35bf95b8bf3d5d8.pnga99b7ace416376c4.pngbd84a6d3004737c5.png

  • 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_ID bezeichnet 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.
  1. 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:

55efc1aaa7a4d3ad.png

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

7ffe5cbb04455448.png

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.js enthält den Node.js-Code
  • package.json definiert die Bibliotheksabhängigkeiten.
  • app.yaml ist die Konfigurationsdatei für Google App Engine.

Ein public-Ordner enthält die statischen Ressourcen:

  • index.html ist die Seite, auf der alle Miniaturansichten und Labels angezeigt werden.
  • collage.html zeigt die Collage mit den aktuellen Bildern
  • upload.html enthält ein Formular zum Hochladen neuer Bilder.
  • app.js verwendet Vue.js, um die Seite index.html mit den Daten zu füllen.
  • script.js verarbeitet das Navigationsmenü und das Dreistrich-Menüsymbol auf kleinen Bildschirmen.
  • style.css definiert 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 Unterverzeichnis public verfü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 /tmp hochgeladen.
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 hochgeladen
  • GET /api/pictures Dieser Endpunkt gibt ein JSON-Dokument mit der Liste der Bilder und ihrer Labels zurück.
  • GET /api/pictures/:name Diese URL leitet zum Cloud Storage-Speicherort des Bildes in voller Größe weiter.
  • GET /api/thumbnails/:name Diese URL leitet zum Cloud Storage-Speicherort des Miniaturbilds weiter.
  • GET /api/collage Diese 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> &nbsp;
                                                        </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:

82fa3266d48c0d0a.png

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:

db0e196b00fceab1.png

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.

6a4d5e5603ba4b73.png

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

Nächste Schritte