1. Przegląd
W tym ćwiczeniu utworzysz internetowy frontend w Google App Engine, który pozwoli użytkownikom przesyłać zdjęcia z aplikacji internetowej oraz przeglądać przesłane zdjęcia i ich miniatury.

Ta aplikacja internetowa będzie używać platformy CSS o nazwie Bulma, aby zapewnić atrakcyjny interfejs użytkownika, oraz platformy JavaScript Vue.JS do wywoływania interfejsu API aplikacji, którą utworzysz.
Ta aplikacja będzie składać się z 3 kart:
- stronę główną, na której będą wyświetlane miniatury wszystkich przesłanych obrazów wraz z listą etykiet opisujących zdjęcie (wykrytych przez Cloud Vision API w poprzednim module);
- Strona collage, na której będzie wyświetlany kolaż utworzony z 4 ostatnio przesłanych zdjęć.
- stronę przesyłania, na której użytkownicy mogą przesyłać nowe zdjęcia;
Wynikowy interfejs wygląda tak:

Te 3 strony to proste strony HTML:
- Strona główna (
index.html) wywołuje kod backendu Node App Engine, aby pobrać listę miniatur i ich etykiet, za pomocą wywołania AJAX do adresu URL/api/pictures. Strona główna używa Vue.js do pobierania tych danych. - Strona collage (
collage.html) wskazuje obrazcollage.png, który składa się z 4 najnowszych zdjęć. - Strona upload (
upload.html) zawiera prosty formularz do przesyłania obrazu za pomocą żądania POST na adres URL/api/pictures.
Czego się nauczysz
- App Engine
- Cloud Storage
- Cloud Firestore
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć.



- Nazwa projektu to wyświetlana nazwa dla uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google i który możesz w każdej chwili zaktualizować.
- Identyfikator projektu musi być unikalny we wszystkich projektach Google Cloud i jest niezmienny (nie można go zmienić po ustawieniu). Konsola Cloud automatycznie generuje unikalny ciąg znaków, który zwykle nie ma znaczenia. W większości modułów codelabs musisz odwołać się do identyfikatora projektu (zwykle jest on oznaczony jako
PROJECT_ID), więc jeśli Ci się nie podoba, wygeneruj inny losowy ciąg znaków lub spróbuj użyć własnego i sprawdź, czy jest dostępny. Po utworzeniu projektu jest on „zamrażany”. - Istnieje też trzecia wartość, numer projektu, która jest używana przez niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć płatności w konsoli Cloud, aby móc korzystać z zasobów i interfejsów API Cloud. Wykonanie tego ćwiczenia nie powinno kosztować dużo, jeśli w ogóle. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, wykonaj instrukcje dotyczące czyszczenia, które znajdziesz na końcu tego ćwiczenia. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.
Uruchamianie Cloud Shell
Chociaż Google Cloud można obsługiwać zdalnie z laptopa, w tym ćwiczeniu wykorzystasz Google Cloud Shell, czyli środowisko wiersza poleceń działające w chmurze.
W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:

Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po zakończeniu powinno wyświetlić się coś takiego:

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Wszystkie zadania w tym module możesz wykonać, używając tylko przeglądarki.
3. Włącz interfejsy API
App Engine wymaga interfejsu Compute Engine API. Sprawdź, czy jest włączona:
gcloud services enable compute.googleapis.com
Powinien pojawić się komunikat o pomyślnym zakończeniu operacji:
Operation "operations/acf.5c5ef4f6-f734-455d-b2f0-ee70b5a17322" finished successfully.
4. Klonowanie kodu
Jeśli jeszcze nie masz kodu, pobierz go:
git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop
Następnie możesz przejść do katalogu zawierającego frontend:
cd serverless-photosharing-workshop/frontend
Układ plików frontendu będzie wyglądał tak:
frontend
|
├── index.js
├── package.json
├── app.yaml
|
├── public
|
├── index.html
├── collage.html
├── upload.html
|
├── app.js
├── script.js
├── style.css
W głównym katalogu projektu znajdują się 3 pliki:
index.jszawiera kod w Node.js,package.jsondefiniuje zależności biblioteki.app.yamlto plik konfiguracji Google App Engine.
Folder public zawiera zasoby statyczne:
index.htmlto strona, na której wyświetlane są wszystkie miniatury i etykiety.collage.htmlpokazuje kolaż z najnowszymi zdjęciamiupload.htmlzawiera formularz do przesyłania nowych zdjęćapp.jsużywa Vue.js do wypełniania stronyindex.htmldanymiscript.jsobsługuje menu nawigacyjne i jego ikonę „hamburgera” na małych ekranach.style.cssdefiniuje niektóre dyrektywy CSS
5. Przeglądanie kodu
Zależności
Plik package.json definiuje wymagane zależności biblioteki:
{
"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"
}
}
Nasza aplikacja wymaga:
- firestore: aby uzyskać dostęp do Cloud Firestore z metadanymi obrazu,
- storage: aby uzyskać dostęp do Google Cloud Storage, gdzie przechowywane są zdjęcia;
- express: platforma internetowa dla Node.js,
- dayjs: niewielka biblioteka do wyświetlania dat w sposób przyjazny dla człowieka,
- bluebird: biblioteka JavaScriptu,
- express-fileupload: biblioteka ułatwiająca przesyłanie plików.
Ekspresowe – frontend
Na początku kontrolera index.js musisz uwzględnić wszystkie zależności zdefiniowane wcześniej w pliku 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)
Następnie tworzona jest instancja aplikacji Express.
Używane są 2 aplikacje pośredniczące Express:
- Wywołanie
express.static()wskazuje, że zasoby statyczne będą dostępne w podkatalogupublic. fileUpload()konfiguruje przesyłanie plików, aby ograniczyć rozmiar pliku do 10 MB i przesłać pliki lokalnie w systemie plików w pamięci w katalogu/tmp.
const app = express();
app.use(express.static('public'));
app.use(fileUpload({
limits: { fileSize: 10 * 1024 * 1024 },
useTempFiles : true,
tempFileDir : '/tmp/'
}))
Wśród zasobów statycznych znajdują się pliki HTML strony głównej, strony kolażu i strony przesyłania. Te strony będą wywoływać backend interfejsu API. Ten interfejs API będzie miał te punkty końcowe:
POST /api/picturesZa pomocą formularza w pliku upload.html zdjęcia będą przesyłane za pomocą żądania POST.GET /api/picturesTen punkt końcowy zwraca dokument JSON zawierający listę zdjęć i ich etykiet.GET /api/pictures/:nameTen adres URL przekierowuje do lokalizacji w Cloud Storage, gdzie znajduje się obraz w pełnym rozmiarze.GET /api/thumbnails/:nameTen adres URL przekierowuje do lokalizacji miniatury obrazu w Cloud Storage.GET /api/collageTen ostatni adres URL przekierowuje do lokalizacji w Cloud Storage, w której znajduje się wygenerowany obraz kolażu.
Przesyłanie zdjęć
Zanim przeanalizujesz kod Node.js do przesyłania zdjęć, rzuć okiem na plik public/upload.html.
...
<form method="POST" action="/api/pictures" enctype="multipart/form-data">
...
<input type="file" name="pictures">
<button>Submit</button>
...
</form>
...
Element formularza wskazuje punkt końcowy /api/pictures, z metodą HTTP POST i formatem wieloczęściowym. Aplikacja index.js musi teraz odpowiedzieć na ten punkt końcowy i metodę oraz wyodrębnić pliki:
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('/');
});
Najpierw sprawdzasz, czy pliki są rzeczywiście przesyłane. Następnie pobierasz pliki lokalnie za pomocą metody mv z naszego modułu Node do przesyłania plików. Pliki są już dostępne w lokalnym systemie plików, więc możesz przesłać zdjęcia do zasobnika Cloud Storage. Na koniec przekierowujesz użytkownika z powrotem do ekranu głównego aplikacji.
Wyświetlam listę zdjęć
Czas wyświetlić Twoje piękne zdjęcia.
W module obsługi /api/pictures sprawdzasz kolekcję pictures w bazie danych Firestore, aby pobrać wszystkie zdjęcia (których miniatury zostały wygenerowane) uporządkowane według daty utworzenia w porządku malejącym.
Każde zdjęcie umieszczasz w tablicy w Javascripcie wraz z jego nazwą, etykietami opisującymi (pochodzącymi z Cloud Vision API), dominującym kolorem i przyjazną datą utworzenia (za pomocą dayjs, używamy względnych przesunięć czasu, takich jak „za 3 dni”).
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);
});
Ten kontroler zwraca wyniki w takim formacie:
[
{
"name": "IMG_20180423_163745.jpg",
"labels": [
"Dish",
"Food",
"Cuisine",
"Ingredient",
"Orange chicken",
"Produce",
"Meat",
"Staple food"
],
"color": "#e78012",
"created": "a day ago"
},
...
]
Ta struktura danych jest wykorzystywana przez mały fragment kodu Vue.js ze strony index.html. Oto uproszczona wersja znaczników z tej strony:
<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>
Identyfikator elementu div wskazuje Vue.js, że jest to część znaczników, która będzie renderowana dynamicznie. Iteracje są wykonywane dzięki dyrektywom v-for.
Zdjęcia mają ładną kolorową ramkę odpowiadającą dominującemu kolorowi na zdjęciu, który został wykryty przez interfejs Cloud Vision API. Wskazujemy miniatury i zdjęcia o pełnej szerokości w źródłach linków i obrazów.
Na koniec wyświetlamy etykiety opisujące obraz.
Oto kod JavaScriptu dla fragmentu kodu Vue.js (w pliku public/app.js zaimportowanym na dole strony index.html):
var app = new Vue({
el: '#app',
data() {
return { pictures: [] }
},
mounted() {
axios
.get('/api/pictures')
.then(response => { this.pictures = response.data })
}
})
Kod Vue używa biblioteki Axios do wywołania AJAX do punktu końcowego /api/pictures. Zwrócone dane są następnie powiązane z kodem widoku w znacznikach, które widzieliśmy wcześniej.
Wyświetlanie zdjęć
W index.html użytkownicy mogą wyświetlać miniatury zdjęć i klikać je, aby zobaczyć obrazy w pełnym rozmiarze, a w collage.html mogą wyświetlać obraz collage.png.
W znacznikach HTML tych stron obraz src i link href wskazują te 3 punkty końcowe, które przekierowują do lokalizacji Cloud Storage zdjęć, miniatur i kolażu. Nie musisz kodować ścieżki na stałe w znacznikach HTML.
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`);
});
Uruchamianie aplikacji Node
Po zdefiniowaniu wszystkich punktów końcowych aplikacja Node.js jest gotowa do uruchomienia. Aplikacja Express domyślnie nasłuchuje na porcie 8080 i jest gotowa do obsługi żądań przychodzących.
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. Testowanie lokalne
Przetestuj kod lokalnie, aby upewnić się, że działa, zanim wdrożysz go w chmurze.
Musisz wyeksportować 2 zmienne środowiskowe odpowiadające 2 zasobnikom Cloud Storage:
export BUCKET_THUMBNAILS=thumbnails-${GOOGLE_CLOUD_PROJECT}
export BUCKET_PICTURES=uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
W folderze frontend zainstaluj zależności npm i uruchom serwer:
npm install; npm start
Jeśli wszystko przebiegło pomyślnie, serwer powinien zostać uruchomiony na porcie 8080:
Started web frontend service on port 8080
- Pictures bucket = uploaded-pictures-${GOOGLE_CLOUD_PROJECT}
- Thumbnails bucket = thumbnails-${GOOGLE_CLOUD_PROJECT}
W tych logach będą widoczne rzeczywiste nazwy zasobników, co jest przydatne podczas debugowania.
W Cloud Shell możesz użyć funkcji podglądu w przeglądarce, aby przeglądać aplikację działającą lokalnie:

Aby go zamknąć, CTRL-C.
7. Wdrażanie w App Engine
Twoja aplikacja jest gotowa do wdrożenia.
Konfigurowanie App Engine
Sprawdź plik konfiguracji app.yaml dla App Engine:
runtime: nodejs16 env_variables: BUCKET_PICTURES: uploaded-pictures-GOOGLE_CLOUD_PROJECT BUCKET_THUMBNAILS: thumbnails-GOOGLE_CLOUD_PROJECT
Pierwszy wiersz deklaruje, że środowisko wykonawcze jest oparte na Node.js 10. Zdefiniowane są 2 zmienne środowiskowe wskazujące na 2 zasobniki: na oryginalne obrazy i na miniatury.
Aby zastąpić GOOGLE_CLOUD_PROJECT rzeczywistym identyfikatorem projektu, możesz uruchomić to polecenie:
sed -i -e "s/GOOGLE_CLOUD_PROJECT/${GOOGLE_CLOUD_PROJECT}/" app.yaml
Wdrażanie
Ustaw preferowany region dla App Engine. Pamiętaj, aby użyć tego samego regionu co w poprzednich modułach:
gcloud config set compute/region europe-west1
I wdrożyć:
gcloud app deploy
Po minucie lub dwóch otrzymasz informację, że aplikacja obsługuje ruch:
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
Możesz też przejść do sekcji App Engine w konsoli Cloud, aby sprawdzić, czy aplikacja została wdrożona, i zapoznać się z funkcjami App Engine, takimi jak obsługa wersji i dzielenie ruchu:

8. Testowanie aplikacji
Aby przetestować, otwórz domyślny adres URL aplikacji App Engine (https://<YOUR_PROJECT_ID>.appspot.com/). Powinien wyświetlić się działający interfejs użytkownika frontendu.

9. Czyszczenie (opcjonalnie)
Jeśli nie zamierzasz zachować aplikacji, możesz wyczyścić zasoby, aby zaoszczędzić koszty i być dobrym obywatelem chmury, usuwając cały projekt:
gcloud projects delete ${GOOGLE_CLOUD_PROJECT}
10. Gratulacje!
Gratulacje! Ta aplikacja internetowa Node.js hostowana w App Engine łączy wszystkie usługi i umożliwia użytkownikom przesyłanie oraz wizualizację zdjęć.
Omówione zagadnienia
- App Engine
- Cloud Storage
- Cloud Firestore