Mikrodienste in Pub/Sub und GKE einbinden

In dieser Anleitung stellen Sie eine Anwendung zum Teilen von Fotos in Google Kubernetes Engine (GKE) bereit. Anhand der Anwendung wird demonstriert, wie Sie mit Pub/Sub Prozesse mit langer Ausführungszeit asynchron aufrufen. Außerdem erfahren Sie, wie Sie mithilfe von Pub/Sub-Benachrichtigungen für Cloud Storage weitere Jobs hinzufügen, ohne den Anwendungscode der Anwendung zu ändern. Die Anwendung wird von Cloud Build containerisiert und in Container Registry gespeichert. Mithilfe von Cloud Vision werden unangemessene Bilder erkannt.

Wenn Sie eine Webanwendung auf Basis einer Mikrodienstarchitektur entwerfen, müssen Sie festlegen, wie die Anwendungsfeatures in Mikrodienste aufgeteilt und diese Mikrodienste über die Anwendung aufgerufen werden. Für zeitintensive Dienste können Sie asynchrone Dienstaufrufe verwenden. Diese Anleitung richtet sich an Entwickler und Architekten, die Mikrodienste mit modernen Technologien wie GKE und Pub/Sub asynchron implementieren möchten.

Die State of DevOps-Berichte haben Faktoren aufgezeigt, die die Leistung bei der Softwarebereitstellung beeinflussen. In dieser Anleitung wird das Architekturfeature erläutert.

Architekturmuster für eine Anwendung zum Generieren von Miniaturansichten

Das folgende Diagramm zeigt ein Beispielszenario, in dem eine Anwendung Miniaturansichten von Bildern generiert.

Grafik: Architektur der in Compute Engine bereitgestellten Anwendung.

Im obigen Diagramm empfängt die Anwendung Bilddateien von Clients und generiert dann automatisch Miniaturansichten. Derzeit ist diese Anwendung mit VM-Instanzen in Compute Engine und mit Back-End-Dateispeicher in Cloud Storage implementiert. Cloud Load Balancing verteilt Anfragen auf mehrere VMs.

Damit sich der operative Aufwand für die Verwaltung von VMs verringert, migrieren Sie dieses System zu einer neuen Architektur, die keine VMs verwendet.

Die neue Architektur, die im folgenden Diagramm dargestellt wird, besteht aus mehreren verwalteten Diensten.

Grafik: Architektur der ohne VMs bereitgestellten Anwendung.

Bei dieser neuen Architektur sendet der Client ein Bild für die Anwendung direkt an Cloud Storage. Anschließend wird über Pub/Sub-Benachrichtigungen eine Nachricht in die Pub/Sub-Nachrichtenwarteschlange gestellt. Die Nachricht ruft einen Mikrodienst auf, der in GKE ausgeführt wird. Der Mikrodienst ruft das Bild aus Cloud Storage ab, generiert eine Miniaturansicht und lädt die Miniaturansicht in Cloud Storage hoch.

Diese neue Architektur bietet folgende Vorteile:

  • Unabhängige Skalierbarkeit: In der ursprünglichen Architektur stellt die in Compute Engine ausgeführte Anwendung zwei Kernfeatures bereit: Eines empfängt Dateien und das andere eine Miniaturansicht aus dem Originalbild. Das Empfangen hochgeladener Dateien beansprucht Netzwerkbandbreite, während das Generieren von Miniaturansichten CPU-intensiv ist. Die Compute Engine-Instanzen könnten also nicht genug CPU-Ressourcen zum Generieren von Bildern haben, obwohl noch ausreichend Netzwerkressourcen zum Empfangen von Dateien vorhanden sind. In der neuen Architektur sind diese Aufgaben auf Cloud Storage und GKE verteilt, wodurch sie unabhängig voneinander skalierbar sind.
  • Effiziente Ressourcennutzung: In der ursprünglichen Architektur werden beim Skalieren von Compute Engine-Instanzen mehr Ressourcen für die Ausführung von Betriebssystemen beansprucht. Mit GKE können Sie Serverressourcen durch Ausführung mehrerer Container auf wenigen Servern effizient nutzen (Bin-Packing). Container lassen sich schnell skalieren, sodass die neue Architektur kurze Lastspitzen bewältigen und danach die Ressourcen schnell wieder herunterskalieren kann.
  • Einfaches Hinzufügen neuer Funktionen: Wenn Sie in der ursprünglichen Architektur Funktionen hinzufügen möchten, müssen Sie diese auf denselben Compute Engine-Instanzen bereitstellen. In der neuen Architektur können Sie eine Anwendung entwickeln, beispielsweise eine Anwendung zum Senden von E-Mails, die sie benachrichtigt, wenn eine neue Miniaturansicht generiert wird. Pub/Sub kann asynchrone Verbindungen zu den Anwendungen zum Generieren von Miniaturansichten und zum Senden von E-Mails herstellen, ohne den ursprünglichen Code auf den Compute Engine-Instanzen zu ändern.
  • Geringere Kopplung: In der alten Architektur stellt die zeitliche Kopplung häufig ein Problem dar. Wenn ein E-Mail-Relais-Server ausfällt und die Anwendung versucht, eine Benachrichtigung zu senden, schlägt das fehl. Da diese Prozesse eng miteinander gekoppelt sind, erhält ein Client unter Umständen keine erfolgreiche Antwort von der Anwendung. In der neuen Architektur ist das anders: Da das Generieren einer Miniaturansicht und das Senden einer Benachrichtigung lose gekoppelt sind, erhält der Client eine erfolgreiche Antwort.

Diese neue Architektur hat folgende Nachteile:

  • Zusätzlicher Aufwand für die Modernisierung der Anwendung: Die Containerisierung einer Anwendung ist zeit- und arbeitsaufwendig. Die neue Architektur verwendet mehr Dienste und muss in Bezug auf die Beobachtbarkeit anders angegangen werden. Dazu sind Änderungen am Anwendungsmonitoring, Deployment-Prozess und Ressourcenmanagement erforderlich.
  • Umgang mit Duplikaten von Miniaturansichten auf Anwendungsseite: Da Pub/Sub mindestens einmalige Nachrichtenzustellung garantiert, können Nachrichten doppelt gesendet werden.

Informationen zur Fotoalbumanwendung

Das folgende Diagramm zeigt das ursprüngliche Design der Fotoalbumanwendung.

Grafik: Architektur der Fotoalbumanwendung.

Das obige Diagramm veranschaulicht, wie die Miniaturansicht generiert wird:

  1. Ein Kunde lädt ein Bild in die Anwendung hoch.
  2. Die Anwendung speichert das Bild in Cloud Storage.
  3. Für die Miniaturansicht wird eine Anfrage generiert.
  4. Der Miniaturansichtsgenerator erstellt die Miniaturansicht.
  5. Die erfolgreiche Antwort wird an die Fotoalbumanwendung gesendet.
  6. Die erfolgreiche Antwort wird an den Client gesendet und die Miniaturansicht ist in Cloud Storage verfügbar.

Nach dem Deployment der Anwendung treten die folgenden Probleme auf:

  • Die Anwendung braucht sehr lang, um die Miniaturansicht zu generieren. Daher treten bei Clients viele Zeitüberschreitungen auf.
  • Das Dienstverwaltungsteam möchte unangemessene hochgeladene Inhalte erkennen. Das Anwendungsteam kann das entsprechende Feature jedoch nicht implementieren, da zu wenig Ressourcen zur Verfügung stehen.

Im folgenden Diagramm wird die Generierung der Miniaturansichten als separater Dienst asynchron extrahiert.

Grafik: Architektur der Extraktion von Miniaturansichten.

Sie verwenden Pub/Sub, um Dienstanfragen an den Dienst zum Generieren von Miniaturansichten zu senden. Diese neue Architektur macht den Dienstaufruf asynchron, sodass im Hintergrund eine Miniaturansicht erstellt wird, nachdem die Anwendung die Antwort an einen Client gesendet hat. Mit diesem Design lässt sich der Dienst zum Generieren von Miniaturansichten außerdem skalieren, sodass mehrere Jobs parallel ausgeführt werden können.

Ziele

  • Exemplarische Fotoalbumanwendung in GKE bereitstellen
  • Asynchrone Dienstaufrufe über die Anwendung ausführen
  • Pub/Sub-Benachrichtigungen für Cloud Storage zum Auslösen der Anwendung verwenden, wenn eine neue Datei in den Cloud Storage-Bucket hochgeladen wird
  • Mithilfe von Pub/Sub weitere Aufgaben ausführen, ohne die Anwendung zu ändern

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  4. GKE, Cloud SQL, Cloud Build, and Cloud Vision APIs aktivieren.

    Aktivieren Sie die APIs

  5. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  6. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  7. GKE, Cloud SQL, Cloud Build, and Cloud Vision APIs aktivieren.

    Aktivieren Sie die APIs

  8. Aktivieren Sie Cloud Shell in der Console.

    Cloud Shell aktivieren

    Unten in der Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

Umgebung einrichten

In diesem Abschnitt weisen Sie Standardeinstellungen für Werte zu, die im gesamten Dokument verwendet werden. Wenn Sie Ihre Cloud Shell-Sitzung schließen, gehen diese Umgebungseinstellungen verloren.

  1. Legen Sie in Cloud Shell Ihr Cloud-Standardprojekt fest und ersetzen Sie project-id durch Ihre Google Cloud-Projekt-ID:

    gcloud config set project project-id
    
  2. Legen Sie Ihre Compute Engine-Standardregion fest und ersetzen Sie region durch eine Region in Ihrer Nähe. Weitere Informationen finden Sie unter Regionen und Zonen.

    gcloud config set compute/region region
    export REGION=region
    
  3. Legen Sie Ihre Compute Engine-Standardzone fest und ersetzen Sie zone durch eine Zone in Ihrer Nähe:

    gcloud config set compute/zone zone
    export ZONE=zone
    
  4. Laden Sie die Dateien für die Anleitung herunter und legen Sie Ihr aktuelles Verzeichnis fest:

    git clone https://github.com/GoogleCloudPlatform/gke-photoalbum-example
    cd gke-photoalbum-example
    

Cloud Storage-Bucket erstellen und Standardbild für Miniaturansicht hochladen

  1. Erstellen Sie in Cloud Shell einen Cloud Storage-Bucket zum Speichern der Originalbilder und Miniaturansichten:

    export PROJECT_ID=$(gcloud config get-value project)
    gsutil mb -c regional -l ${REGION} gs://${PROJECT_ID}-photostore
    
  2. Laden Sie die Standarddatei für die Miniaturansicht hoch:

    gsutil cp ./application/photoalbum/images/default.png \
        gs://${PROJECT_ID}-photostore/thumbnails/default.png
    
    • Die hochgeladenen Bilder werden im folgenden Format gespeichert: gs://project-id-photostore/filename, wobei filename für den Namen der hochgeladenen Bilddatei steht.
    • Die generierten Miniaturansichten werden im folgenden Format gespeichert: gs://project-id-photostore/thumbnails/filename.
    • Das Originalbild und die zugehörige Miniaturansicht haben denselben filename-Wert, die Miniaturansicht wird jedoch im Bucket thumbnails gespeichert.
    • Während die Miniaturansicht erstellt wird, ist das Platzhalterbild für die Miniaturansicht default.png in der Fotoalbumanwendung zu sehen.

      Grafik: Standardplatzhalterbild für die Miniaturansicht.

  3. Veröffentlichen Sie die Datei mit der Miniaturansicht:

    gsutil acl ch -u AllUsers:R \
        gs://${PROJECT_ID}-photostore/thumbnails/default.png
    

Cloud SQL-Instanz und MySQL-Datenbank erstellen

  1. Erstellen Sie die Cloud SQL-Instanz in Cloud Shell:

    gcloud sql instances create photoalbum-db --region=${REGION} \
        --database-version=MYSQL_5_7
    
  2. Rufen Sie den Verbindungsnamen ab:

    gcloud sql instances describe photoalbum-db \
        --format="value(connectionName)"
    

    Notieren Sie sich den Namen. Sie benötigen ihn später in dieser Anleitung.

  3. Legen Sie das Passwort für den MySQL-Nutzer root@% fest:

    gcloud sql users set-password root --host=% --instance=photoalbum-db \
        --password=password
    

    Ersetzen Sie password durch ein sicheres Passwort für den Nutzer root@%.

  4. Stellen Sie eine Verbindung zur Cloud SQL-Instanz her:

    gcloud sql connect photoalbum-db --user=root --quiet
    

    Bei entsprechender Aufforderung geben Sie das password ein, das Sie im vorherigen Schritt eingerichtet haben.

  5. Erstellen Sie eine Datenbank mit dem Namen photo_db, wobei der Nutzer appuser und das Passwort pas4appuser ist:

    create database photo_db;
    grant all privileges on photo_db.* to appuser@"%" \
        identified by 'pas4appuser' with grant option;
    
  6. Bestätigen Sie das Ergebnis und beenden Sie MySQL:

    show databases;
    select user from mysql.user;
    exit
    

    Bestätigen Sie in der Ausgabe, dass die Datenbank photo_db und der Nutzer appuser erstellt wurden:

    MySQL [(none)]> show databases;
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | mysql              |
    | performance_schema |
    | photo_db           |
    | sys                |
    +--------------------+
    5 rows in set (0.16 sec)
    
    MySQL [(none)]> select user from mysql.user;
    +-----------+
    | user      |
    +-----------+
    | appuser   |
    | root      |
    | mysql.sys |
    +-----------+
    3 rows in set (0.16 sec)
    
    MySQL [(none)]> exit
    Bye
    

Pub/Sub-Thema und -Abo erstellen

  1. Erstellen Sie in Cloud Shell ein Pub/Sub-Thema mit dem Namen thumbnail-service:

    gcloud pubsub topics create thumbnail-service
    

    Die Fotoalbumanwendung veröffentlicht eine Nachricht im Thema thumbnail-service, um Anfragen an den Dienst zum Generieren von Miniaturansichten zu senden.

  2. Erstellen Sie ein Pub/Sub-Abo mit dem Namen thumbnail-workers:

    gcloud pubsub subscriptions create --topic thumbnail-service thumbnail-workers
    

    Der Dienst zum Generieren von Miniaturansichten erhält Anfragen vom Abo thumbnail-workers.

GKE-Cluster erstellen

  1. Erstellen Sie in Cloud Shell einen GKE-Cluster mit der Berechtigung zum Aufrufen von APIs:

    gcloud container clusters create "photoalbum-cluster" \
        --scopes "https://www.googleapis.com/auth/cloud-platform" \
        --num-nodes "5"
    
  2. Rufen Sie Anmeldedaten für den Zugriff ab, die so konfiguriert sind, dass Sie den Cluster in späteren Schritten mit dem kubectl-Befehl verwalten können:

    gcloud container clusters get-credentials photoalbum-cluster
    
  3. Listen Sie die Knoten auf:

    kubectl get nodes
    

    Bestätigen Sie in der Ausgabe, dass es fünf Knoten mit einem STATUS von Ready gibt:

    NAME                                                STATUS    ROLES     AGE       VERSION
    gke-photoalbum-cluster-default-pool-0912a91a-24vt   Ready     <none>    6m        v1.9.7-gke.6
    gke-photoalbum-cluster-default-pool-0912a91a-5h1n   Ready     <none>    6m        v1.9.7-gke.6
    gke-photoalbum-cluster-default-pool-0912a91a-gdm9   Ready     <none>    6m        v1.9.7-gke.6
    gke-photoalbum-cluster-default-pool-0912a91a-swv6   Ready     <none>    6m        v1.9.7-gke.6
    gke-photoalbum-cluster-default-pool-0912a91a-thv8   Ready     <none>    6m        v1.9.7-gke.6
    

Images für die Anwendung erstellen

  1. Öffnen Sie die Datei application/photoalbum/src/auth_decorator.py in einem Texteditor und aktualisieren Sie den Nutzernamen und das Passwort:

    USERNAME = 'username'
    PASSWORD = 'passw0rd'
    
  2. Erstellen Sie in Cloud Shell mit dem Cloud Build-Dienst ein Image für die Fotoalbumanwendung:

    gcloud builds submit ./application/photoalbum -t \
        gcr.io/${PROJECT_ID}/photoalbum-app
    
  3. Erstellen Sie mit dem Cloud Build-Dienst ein Image für den Dienst zum Generieren von Miniaturansichten thumbnail-worker:

    gcloud builds submit ./application/thumbnail -t \
        gcr.io/${PROJECT_ID}/thumbnail-worker
    

Fotoalbumanwendung bereitstellen

  1. Aktualisieren Sie in Cloud Shell die Kubernetes-Deployment-Manifeste für das Fotoalbum und den Miniaturansichtsgenerator mit Werten aus Ihrer Umgebung:

    connection_name=$(gcloud sql instances describe photoalbum-db \
        --format "value(connectionName)")
    
    digest_photoalbum=$(gcloud container images describe \
        gcr.io/${PROJECT_ID}/photoalbum-app:latest --format \
        "value(image_summary.digest)")
    
    sed -i.bak -e "s/\[PROJECT_ID\]/${PROJECT_ID}/" \
        -e "s/\[CONNECTION_NAME\]/${connection_name}/" \
        -e "s/\[DIGEST\]/${digest_photoalbum}/" \
        config/photoalbum-deployment.yaml
    
    digest_thumbnail=$(gcloud container images describe \
        gcr.io/${PROJECT_ID}/thumbnail-worker:latest --format \
        "value(image_summary.digest)")
    
    sed -i.bak -e "s/\[PROJECT_ID\]/${PROJECT_ID}/" \
        -e "s/\[CONNECTION_NAME\]/${connection_name}/" \
        -e "s/\[DIGEST\]/${digest_thumbnail}/" \
            config/thumbnail-deployment.yaml
    
  2. Erstellen Sie Deployment-Ressourcen, um die Fotoalbumanwendung und den Dienst zum Generieren von Miniaturansichten zu starten:

    kubectl create -f config/photoalbum-deployment.yaml
    kubectl create -f config/thumbnail-deployment.yaml
    
  3. Erstellen Sie eine Dienstressource, um der Anwendung eine externe IP-Adresse zuzuweisen:

    kubectl create -f config/photoalbum-service.yaml
    
  4. Prüfen Sie die Ergebnisse für die Pods:

    kubectl get pods
    

    Bestätigen Sie in der Ausgabe, dass es drei Pods für jede photoalbum-app und jeden thumbail-worker mit einem STATUS von Running gibt:

    NAME                                READY     STATUS    RESTARTS   AGE
    photoalbum-app-555f7cbdb7-cp8nw     2/2       Running   0          2m
    photoalbum-app-555f7cbdb7-ftlc6     2/2       Running   0          2m
    photoalbum-app-555f7cbdb7-xsr4b     2/2       Running   0          2m
    thumbnail-worker-86bd95cd68-728k5   2/2       Running   0          2m
    thumbnail-worker-86bd95cd68-hqxqr   2/2       Running   0          2m
    thumbnail-worker-86bd95cd68-xnxhc   2/2       Running   0          2m
    
  5. Prüfen Sie die Ergebnisse für die Dienste:

    kubectl get services
    

    Bestätigen Sie in der Ausgabe, dass in der Spalte EXTERNAL-IP eine externe IP-Adresse für photoalbum-service vorhanden ist. Es kann einige Minuten dauern, bis alles eingestellt und einsatzbereit ist.

    NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
    kubernetes           ClusterIP      10.23.240.1     <none>            443/TCP        20m
    photoalbum-service   LoadBalancer   10.23.253.241   146.148.111.115   80:32657/TCP   2m
    

    Notieren Sie sich die externe IP-Adresse, da sie später in dieser Anleitung verwendet wird. In diesem Beispiel ist das 146.148.111.115.

Fotoalbumanwendung testen

  1. Wenn Sie in einem Webbrowser auf die bereitgestellte Anwendung zugreifen möchten, rufen Sie die folgende URL auf und geben den zuvor eingerichteten Nutzernamen und das zugehörige Passwort ein:

    http://external-ip
    

    Ersetzen Sie external-ip durch die IP-Adresse, die Sie im vorherigen Schritt notiert haben.

  2. Klicken Sie zum Hochladen einer Bilddatei Ihrer Wahl auf Hochladen. Der Platzhalter für die Miniaturansicht wird auf dem Bildschirm angezeigt.

    Grafik: Platzhalter für die Miniaturansicht, der angezeigt wird, während der Dienst eine spezifische Miniaturansicht generiert.

    Im Hintergrund erstellt der Dienst zum Generieren von Miniaturansichten eine Miniaturansicht des hochgeladenen Bildes. Damit Sie die generierte Miniaturansicht sehen, klicken Sie auf Aktualisieren. Die Cloud Vision API fügt die von ihr erkannten Bildlabels hinzu.

    Grafik: Miniaturansicht mit zugehörigen Bildlabels.

    Damit Sie das Originalbild sehen, klicken Sie auf die Miniaturansicht.

Feature zum Erkennen unangemessener Bilder hinzufügen

Die folgende Abbildung zeigt, wie Sie mithilfe von Pub/Sub-Benachrichtigungen für Cloud Storage einen Dienst auslösen können, der unangemessene Inhalte erkennt. Mit diesem Feature wird das Bild unkenntlich gemacht, wenn eine neue Datei mit unangemessenem Inhalt im Cloud Storage-Bucket gespeichert wird.

Grafik: Architektur des Features zum Erkennen unangemessener Inhalte.

In der vorherigen Abbildung verwendet der Dienst das Feature SafeSearch-Erkennung der Vision API, um unangemessene Inhalte in einem Bild zu erkennen.

Pub/Sub-Thema, -Abo und -Benachrichtigung erstellen

  1. Erstellen Sie in Cloud Shell ein Pub/Sub-Thema mit dem Namen safeimage-service:

    gcloud pubsub topics create safeimage-service
    
  2. Erstellen Sie ein Pub/Sub-Abo mit dem Namen safeimage-workers:

    gcloud pubsub subscriptions create --topic safeimage-service \
        safeimage-workers
    
  3. Konfigurieren Sie eine Pub/Sub-Benachrichtigung, sodass eine Nachricht an das Thema safeimage-service gesendet wird, wenn eine neue Datei in den Cloud Storage-Bucket hochgeladen wird:

    gsutil notification create -t safeimage-service -f json \
        gs://${PROJECT_ID}-photostore
    

Worker-Image erstellen und bereitstellen

  1. Erstellen Sie in Cloud Shell mit Cloud Build ein Container-Image für das Abo safeimage-workers:

    gcloud builds submit ./application/safeimage \
        -t gcr.io/${PROJECT_ID}/safeimage-worker
    
  2. Aktualisieren Sie die Kubernetes-Deployment-Manifeste für den Dienst "safe-image" mit Ihrer Cloud-Projekt-ID, dem Cloud SQL-Verbindungsnamen und den Container-Image-Digests:

    digest_safeimage=$(gcloud container images describe \
        gcr.io/${PROJECT_ID}/safeimage-worker:latest --format \
        "value(image_summary.digest)")
    sed -i.bak -e "s/\[PROJECT_ID\]/${PROJECT_ID}/" \
        -e "s/\[CONNECTION_NAME\]/${connection_name}/" \
        -e "s/\[DIGEST\]/${digest_safeimage}/" \
        config/safeimage-deployment.yaml
    

Deployment-Ressource erstellen

  1. Erstellen Sie eine Deployment-Ressource mit dem Namen safeimage-deployment, um das Thema safeimage-service bereitzustellen:

    kubectl create -f config/safeimage-deployment.yaml
    
  2. Prüfen Sie die Ergebnisse:

    kubectl get pods
    

    Bestätigen Sie in der Ausgabe, dass es drei Pods von safeimage-worker mit einem STATUS von Running gibt.

    NAME                                READY     STATUS    RESTARTS   AGE
    photoalbum-app-555f7cbdb7-cp8nw     2/2       Running   0          30m
    photoalbum-app-555f7cbdb7-ftlc6     2/2       Running   0          30m
    photoalbum-app-555f7cbdb7-xsr4b     2/2       Running   8          30m
    safeimage-worker-7dc8c84f54-6sqzs   1/1       Running   0          2m
    safeimage-worker-7dc8c84f54-9bskw   1/1       Running   0          2m
    safeimage-worker-7dc8c84f54-b7gtp   1/1       Running   0          2m
    thumbnail-worker-86bd95cd68-9wrpv   2/2       Running   0          30m
    thumbnail-worker-86bd95cd68-kbhsn   2/2       Running   2          30m
    thumbnail-worker-86bd95cd68-n4rj7   2/2       Running   0          30m
    

Feature zum Erkennen unangemessener Bilder testen

In diesem Abschnitt laden Sie ein Testbild hoch, um zu prüfen, ob das Feature SafeSearch-Erkennung ein unangemessenes Bild unkenntlich macht. Das Testbild ist ein Bild von einem Mädchen, das als Zombie verkleidet ist (lizenziert unter einer CC0-Lizenz von Pixaby).

  1. Laden Sie das Testbild herunter.
  2. Zum Hochladen des Bildes rufen Sie http://external-ip auf und klicken dann auf Hochladen.
  3. Klicken Sie auf Aktualisieren. Die Anwendung zeigt eine unkenntlich gemachte Miniaturansicht an.

    Grafik: Unkenntlich gemachte Miniaturansicht.

    Klicken Sie auf die Miniaturansicht, um festzustellen, ob das hochgeladene Bild ebenfalls unkenntlich gemacht wurde.

Bereinigen

Am einfachsten können Sie die Abrechnung deaktivieren, wenn Sie das Cloud-Projekt löschen, das Sie für die Anleitung erstellt haben. Alternativ haben Sie die Möglichkeit, die einzelnen Ressourcen zu löschen.

Projekt löschen

  1. Wechseln Sie in der Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Einzelne Ressourcen löschen

Anstatt das Projekt zu löschen, können Sie die Ressourcen löschen, die Sie in dieser Anleitung erstellt haben.

  1. Löschen Sie Ressourcen aus GKE:

    kubectl delete -f config/safeimage-deployment.yaml
    kubectl delete -f config/photoalbum-service.yaml
    kubectl delete -f config/thumbnail-deployment.yaml
    kubectl delete -f config/photoalbum-deployment.yaml
    
  2. Löschen Sie den Cluster aus GKE:

    gcloud container clusters delete photoalbum-cluster --quiet
    
  3. Löschen Sie Images aus Container Registry:

    gcloud container images delete safeimage-worker
    gcloud container images delete thumbnail-worker
    gcloud container images delete photoalbum-app
    
  4. Löschen Sie Abos und Themen aus Pub/Sub:

    gcloud pubsub subscriptions delete safeimage-workers
    gcloud pubsub topics delete safeimage-service
    gcloud pubsub subscriptions delete thumbnail-workers
    gcloud pubsub topics delete thumbnail-service
    
  5. Löschen Sie die Cloud SQL-Instanz:

    gcloud sql instances delete photoalbum-db --quiet
    
  6. Löschen Sie den Cloud Storage-Bucket:

    gsutil rm -r gs://${PROJECT_ID}-photostore
    gsutil rm -r gs://${PROJECT_ID}_cloudbuild
    
  7. Löschen Sie die Dateien:

    cd ..
    rm -rf gke-photoalbum-example
    

Nächste Schritte