Esegui il deployment dell'elaborazione delle immagini utilizzando microservizi e messaggistica asincrona

Last reviewed 2023-07-17 UTC

Questo documento descrive come implementare l'architettura di riferimento descritto in Integra i microservizi con Pub/Sub e GKE. L'architettura è progettata per gestire processi a lunga esecuzione utilizzando di container e messaggistica asincrone.

Il documento utilizza un'applicazione di condivisione delle foto di esempio che genera una foto. miniature. Il deployment dell'applicazione viene eseguito utilizzando Google Kubernetes Engine (GKE) e e usare Pub/Sub per richiamare i processi a lunga esecuzione in modo asincrono. Puoi usare le notifiche Pub/Sub anche per Cloud Storage aggiungere job collaterali senza modificare il codice dell'applicazione.

L'applicazione è containerizzata da Cloud Build e archiviata in Artifact Registry. Utilizza Cloud Vision per rilevare immagini inappropriate.

Architettura

Il seguente diagramma illustra il design dell'album fotografico di esempio che implementano architettura di riferimento.

Figura 1. Architettura per l'elaborazione delle immagini basata sull'utilizzo di container e messaggistica asincrone.

Il diagramma precedente illustra come viene generata la miniatura:

1. Un client carica un'immagine nell'applicazione.
2. L'applicazione archivia l'immagine Cloud Storage.
3. Viene generata una richiesta per la miniatura.
4. Il generatore di miniature genera la miniatura.
5. La risposta viene inviata all'applicazione album fotografico.
6. La risposta corretta viene inviata al client, dove puoi trovare il miniatura in Cloud Storage.

Il seguente diagramma mostra in che modo l'applicazione implementa la generazione delle miniature come servizio separato in modo asincrono.

Figura 2. Architettura del processo di estrazione delle miniature.

Utilizza Pub/Sub per inviare richieste di servizio alla miniatura completamente gestito di Google Cloud. Questa nuova architettura rende la chiamata di servizio asincrona, crea una miniatura in background dopo che l'applicazione ha inviato a un cliente. Questo design consente anche di generare miniature scalare in modo che più job possano essere eseguiti in parallelo.

Obiettivi

• Eseguire il deployment di un'applicazione di album fotografico di esempio su GKE.
• Consente di effettuare chiamate di servizio asincrone dall'applicazione.
• Utilizzare le notifiche Pub/Sub per Cloud Storage per attiva l'applicazione quando viene caricato un nuovo file in Cloud Storage di sincronizzare la directory di una VM con un bucket.
• Utilizza Pub/Sub per eseguire più attività senza modificare il un'applicazione.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• Cloud Storage
• Cloud SQL
• Pub/Sub
• Compute Engine instances used by GKE
• Cluster-management fee for GKE
• Cloud Load Balancing
• Cloud Build
• Artifact Registry
• Vision

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Quando finisci di creare l'applicazione di esempio, puoi evitare ed eliminare le risorse che hai creato. Per ulteriori informazioni, vedi Esegui la pulizia.

Prima di iniziare

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

3. Abilita le API GKE, Cloud SQL, Cloud Build, Artifact Registry, and Cloud Vision.

   Abilita le API

4. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Configura l'ambiente

In questa sezione assegni le impostazioni predefinite per i valori utilizzati in tutto il documento. Se chiudi la sessione di Cloud Shell, perdere le impostazioni dell'ambiente.

1. In Cloud Shell, imposta il tuo progetto Google Cloud predefinito:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

2. Imposta la regione predefinita per Compute Engine:

   gcloud config set compute/region REGION
   export REGION=REGION
   

   Sostituisci REGION con una regione vicina a te. Per ulteriori informazioni, vedi Regioni e zone.

3. Imposta la zona Compute Engine predefinita:

   gcloud config set compute/zone ZONE
   export ZONE=ZONE
   

   Sostituisci ZONE con una zona vicina a te.

4. Scarica i file dell'applicazione di esempio e imposta la directory attuale:

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

Crea un bucket Cloud Storage e carica l'immagine in miniatura predefinita

1. In Cloud Shell, crea un bucket Cloud Storage archiviare le immagini e le miniature originali:

   export PROJECT_ID=$(gcloud config get-value project)
   gcloud storage buckets create gs://${PROJECT_ID}-photostore --location=${REGION}
   

2. Carica il file della miniatura predefinita:

   gcloud storage cp ./application/photoalbum/images/default.png \
       gs://${PROJECT_ID}-photostore/thumbnails/default.png
   

   • Le immagini caricate vengono archiviate nel seguente formato: gs://PROJECT_ID-photostore/FILENAME, dove FILENAME rappresenta il nome del file immagine viene caricato.
   • Le miniature generate vengono memorizzate nel seguente formato: gs://PROJECT_ID-photostore/thumbnails/FILENAME.
   • L'immagine originale e la miniatura corrispondente hanno lo lo stesso valore di FILENAME, ma la miniatura è memorizzata nel bucket thumbnails.

   • Durante la creazione della miniatura, i seguenti default.png nell'applicazione Album fotografico viene visualizzata l'immagine in miniatura segnaposto.

     

3. Per rendere pubblico il file della miniatura:

   gcloud storage buckets add-iam-policy-binding gs://${PROJECT_ID}-photostore \
       --member=allUsers --role=roles/storage.objectViewer
   

crea un'istanza Cloud SQL e un database MySQL

1. In Cloud Shell, crea l'istanza Cloud SQL:

   gcloud sql instances create photoalbum-db --region=${REGION} \
       --database-version=MYSQL_8_0
   

2. Recupera il nome della connessione:

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

   Annota questo nome perché lo utilizzerai in seguito.

3. Imposta la password per l'utente MySQL root@%:

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

   Sostituisci PASSWORD con una password sicura per il root@%utente.

4. Connettiti all'istanza Cloud SQL:

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

   Quando viene richiesto, inserisci la password che hai impostato nel passaggio precedente.

5. Crea un database denominato photo_db, in cui l'utente è appuser e il la password è pas4appuser:

   create database photo_db;
   create user 'appuser'@'%' identified by 'pas4appuser';
   grant all on photo_db.* to 'appuser'@'%' with grant option;
   flush privileges;
   

6. Conferma il risultato ed esci da MySQL:

   show databases;
   select user from mysql.user;
   exit
   

   Nell'output, verifica che il database photo_db e appuser vengono creati:

   mysql> show databases;
   +--------------------+
   | Database           |
   +--------------------+
   | information_schema |
   | mysql              |
   | performance_schema |
   | photo_db           |
   | sys                |
   +--------------------+
   5 rows in set (0.16 sec)
   
   mysql> \t
   Outfile disabled.
   mysql> select user from mysql.user;
   +-------------------+
   | user              |
   +-------------------+
   | appuser           |
   | cloudsqlreplica   |
   | cloudsqlsuperuser |
   | root              |
   | cloudsqlexport    |
   | cloudsqlimport    |
   | cloudsqloneshot   |
   | root              |
   | cloudsqlexport    |
   | cloudsqlimport    |
   | cloudsqloneshot   |
   | root              |
   | cloudsqlapplier   |
   | cloudsqlimport    |
   | mysql.infoschema  |
   | mysql.session     |
   | mysql.sys         |
   | root              |
   +-------------------+
   18 rows in set (0.16 sec)
   
   mysql> exit
   Bye
   

crea un argomento Pub/Sub e una sottoscrizione

1. In Cloud Shell, crea un argomento Pub/Sub denominato thumbnail-service:

   gcloud pubsub topics create thumbnail-service
   

   L'applicazione Album fotografico invia richieste alla generazione delle miniature servizio pubblicando un messaggio sull'argomento thumbnail-service.

2. Crea una sottoscrizione Pub/Sub denominata thumbnail-workers:

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

   Il servizio di generazione delle miniature riceve le richieste Abbonamento a thumbnail-workers.

Crea un cluster GKE

1. In Cloud Shell, crea un cluster GKE con l'autorizzazione a chiamare le API:

   gcloud container clusters create "photoalbum-cluster" \
       --scopes "https://www.googleapis.com/auth/cloud-platform" \
       --num-nodes "5"
   

2. Ottieni le credenziali di accesso configurate in modo da poter gestire il cluster utilizzando il comando kubectl nei passaggi successivi:

   gcloud container clusters get-credentials photoalbum-cluster
   

3. Mostra l'elenco dei nodi:

   kubectl get nodes
   

   Nell'output, verifica che siano presenti cinque nodi il cui valore STATUS sia Ready:

   NAME                                                STATUS   ROLES    AGE     VERSION
   gke-photoalbum-cluster-default-pool-d637570a-2pfh   Ready    <none>   2m55s   v1.24.10-gke.2300
   gke-photoalbum-cluster-default-pool-d637570a-3rm4   Ready    <none>   2m55s   v1.24.10-gke.2300
   gke-photoalbum-cluster-default-pool-d637570a-f7l4   Ready    <none>   2m55s   v1.24.10-gke.2300
   gke-photoalbum-cluster-default-pool-d637570a-qb2z   Ready    <none>   2m53s   v1.24.10-gke.2300
   gke-photoalbum-cluster-default-pool-d637570a-rvnp   Ready    <none>   2m54s   v1.24.10-gke.2300
   

Crea il repository Artifact Registry

• In Cloud Shell, crea un repository in cui archiviare le immagini container:

  gcloud artifacts repositories create photoalbum-repo \
      --repository-format=docker \
      --location=us-central1 \
      --description="Docker repository"
  

Crea immagini per l'applicazione

1. In un editor di testo, apri application/photoalbum/src/auth_decorator.py e aggiorna il nome utente e la password:

   USERNAME = 'username'
   PASSWORD = 'passw0rd'
   

2. In Cloud Shell, crea un'immagine per l'applicazione Album fotografico utilizzando il servizio Cloud Build:

   gcloud builds submit ./application/photoalbum -t \
       us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/photoalbum-app
   

3. Crea un'immagine per il servizio di generazione di miniature thumbnail-worker con il servizio Cloud Build:

   gcloud builds submit ./application/thumbnail -t \
       us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/thumbnail-worker
   

Implementare l'applicazione Album fotografico

1. In Cloud Shell, aggiorna i manifest del deployment Kubernetes per l'album di foto e il generatore di miniature con i valori dei tuoi questo ambiente:

   connection_name=$(gcloud sql instances describe photoalbum-db \
       --format "value(connectionName)")
   
   digest_photoalbum=$(gcloud container images describe \
       us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/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 \
       us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/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. Creare risorse di deployment per avviare l'applicazione album fotografico e di generazione delle miniature:

   kubectl create -f config/photoalbum-deployment.yaml
   kubectl create -f config/thumbnail-deployment.yaml
   

3. Crea una risorsa di servizio per assegnare un indirizzo IP esterno applicazione:

   kubectl create -f config/photoalbum-service.yaml
   

4. Controlla i risultati per i pod:

   kubectl get pods
   

   Nell'output, verifica che ci siano tre pod per ogni photoalbum-app e thumbail-worker e che il loro valore STATUS sia Running:

   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
   

   Il pod thumbnail-worker sottoscrive le richieste di generazione delle miniature da l'abbonamento a thumbnail-workers. Per ulteriori informazioni, vedi come La funzione callback viene utilizzata nel codice sorgente.

5. Verifica i risultati per i servizi:

   kubectl get services
   

   Nell'output, conferma che sia presente un indirizzo IP esterno Colonna EXTERNAL-IP per il servizio photoalbum-service. L'operazione potrebbe alcuni minuti prima che tutti i servizi siano in esecuzione.

   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
   

   Prendi nota dell'indirizzo IP esterno perché verrà utilizzato in seguito. In questo ad esempio 146.148.111.115.

Prova l'applicazione Album fotografico

1. Per accedere all'applicazione di cui è stato eseguito il deployment in un browser web, vai all'URL seguente e inserisci nome utente e password impostati in precedenza:

   http://EXTERNAL_IP
   

   Sostituisci EXTERNAL_IP con l'indirizzo IP che copiato nel passaggio precedente.

2. Per caricare un file immagine, fai clic su Carica.

   

   Il segnaposto della miniatura viene visualizzato sullo schermo.

   In background, il servizio di generazione delle miniature crea una miniatura dell'immagine caricata. Per visualizzare la miniatura generata, fai clic su Aggiorna. L'API Cloud Vision aggiunge le etichette delle immagini che rileva.

   

   Per vedere l'immagine originale, fai clic sulla miniatura.

Aggiungere una funzionalità di rilevamento di immagini inappropriate

L'immagine seguente illustra come utilizzare Pub/Sub notifiche per Cloud Storage per attivare un servizio che rileva contenuti inappropriati. Questa funzionalità sfoca l'immagine quando un nuovo file contiene vengono archiviati contenuti inappropriati nel bucket Cloud Storage.

Nell'immagine precedente, il servizio utilizza Rilevamento SafeSearch funzionalità dell'API Vision per rilevare contenuti inappropriati all'interno di un dell'immagine.

L'applicazione per le foto attiva il generatore di miniature e il controllo delle immagini in modo asincrono. Di conseguenza, non vi è alcuna garanzia che vengano eseguite in un ordine specifico. Se la generazione della miniatura avviene prima dell'immagine è sfocato, per un po' di tempo potresti vedere una miniatura inappropriata. Tuttavia, il controllo immagini alla fine sfoca sia l'immagine inappropriata che miniatura inappropriata.

Crea un argomento, una sottoscrizione e una notifica Pub/Sub

1. In Cloud Shell, crea un argomento Pub/Sub denominato safeimage-service:

   gcloud pubsub topics create safeimage-service
   

2. Crea una sottoscrizione Pub/Sub denominata safeimage-workers:

   gcloud pubsub subscriptions create --topic safeimage-service \
       safeimage-workers
   

3. Configura un Notifica Pub/Sub in modo che venga inviato un messaggio all'argomento safeimage-service quando viene creato un nuovo file viene caricato nel bucket Cloud Storage:

   gcloud storage buckets notifications create gs://${PROJECT_ID}-photostore \
       --topic=safeimage-service --payload-format=json
   

Crea ed esegui il deployment dell'immagine worker

1. In Cloud Shell, crea un'immagine container per safeimage-workers utilizzando Cloud Build:

   gcloud builds submit ./application/safeimage \
       -t us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/safeimage-worker
   

2. Aggiorna i manifest di deployment di Kubernetes per il servizio secure-image con l'ID progetto Google Cloud, il nome della connessione Cloud SQL, e digest delle immagini container:

   digest_safeimage=$(gcloud container images describe \
       us-central1-docker.pkg.dev/${PROJECT_ID}/photoalbum-repo/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
   

Crea una risorsa di deployment

1. Per eseguire il deployment, crea una risorsa di deployment denominata safeimage-deployment l'argomento safeimage-service:

   kubectl create -f config/safeimage-deployment.yaml
   

2. Controlla i risultati:

   kubectl get pods
   

   Nell'output, verifica che siano presenti tre pod safeimage-worker la cui Il valore di STATUS è Running.

   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
   

   I pod safeimage-worker si abbonano per il rilevamento di immagini inappropriate richieste dall'abbonamento safeimage-workers. Per maggiori informazioni informazioni, vedi come viene utilizzata la funzione callback codice sorgente.

Testa la funzionalità di rilevamento di immagini inappropriate

In questa sezione, caricherai un'immagine di prova per verificare che Rilevamento SafeSearch la funzionalità sfoca un'immagine inappropriata. L'immagine di test è l'immagine ragazza vestita da zombie (con licenza concessa una licenza CC0 di Pixaby).

1. Scarica l'immagine di prova.
2. Per caricare l'immagine, vai su http://EXTERNAL_IP e e fai clic su Carica.

3. Fai clic su Aggiorna. L'applicazione mostra una miniatura sfocata.

   

   Per vedere che anche l'immagine caricata è sfocata, fai clic sulla miniatura.

Esegui la pulizia

Se non vuoi conservare le risorse Google Cloud che hai creato l'applicazione di esempio, puoi rimuoverle in modo che non ti venga addebitato alcun costo in futuro. Puoi eliminare completamente il progetto o eliminare il cluster ed eliminare il cluster.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le singole risorse

Anziché eliminare il progetto, puoi eliminare le singole risorse che hai creato.

1. Elimina le risorse da 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. Elimina il cluster da GKE:

   gcloud container clusters delete photoalbum-cluster --quiet
   

3. Elimina il repository da Artifact Registry:

   gcloud artifacts repositories delete photoalbum-repo --location us-central1 --quiet
   

4. Elimina sottoscrizioni e argomenti da 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. Elimina l'istanza Cloud SQL:

   gcloud sql instances delete photoalbum-db --quiet
   

6. Elimina il bucket Cloud Storage:

   gcloud storage rm gs://${PROJECT_ID}-photostore --recursive
   gcloud storage rm gs://${PROJECT_ID}_cloudbuild --recursive
   

7. Elimina i file:

   cd ..
   rm -rf gke-photoalbum-example
   

Passaggi successivi

• Informazioni DevOps e scopri di più sulle Architettura funzionalità correlate a questa architettura di riferimento.
• Prendi l' Controllo rapido DevOps per capire a che punto sei rispetto al resto del settore.
• Per altre architetture di riferimento, diagrammi e best practice, esplora il Centro architetture cloud.