Questo documento descrive come creare l'architettura descritta in API Smart per prevedere la propensione all'acquisto dei clienti utilizzando Apigee, BigQuery ML e Spanner. In questa architettura, puoi utilizzare questi prodotti per eseguire il deployment di un'API che può prevedere la probabilità che un cliente effettui un acquisto.
Queste istruzioni sono rivolte agli sviluppatori di API e agli esperti di dati che vogliono generare più entrate tramite piattaforme omnicanale ed e-commerce fornendo un'esperienza più personalizzata agli utenti. Presuppone che tu abbia familiarità con Apigee, BigQuery ML, Spanner, Google Cloud CLI e Apache Maven.
Architettura
Il seguente diagramma mostra l'architettura e il processo utilizzati in questa soluzione:
Per maggiori dettagli, consulta API intelligente per prevedere la propensione all'acquisto dei clienti utilizzando Apigee, BigQuery ML e Spanner.
Obiettivi
- Crea un set di dati per la propensione all'acquisto dei clienti in BigQuery.
- Importa i dati del catalogo dei prodotti nel database Spanner.
- Importa ed esegui il deployment di un proxy API Apigee.
- Integra i dati sulla propensione all'acquisto dei clienti da BigQuery con il catalogo dei prodotti e le informazioni sui prezzi dal database Spanner.
- Crea una visualizzazione aggregata dei suggerimenti sui prodotti.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
- Slot flessibili di BigQuery e BigQuery ML
- Spanner
- Apigee
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
Prima di iniziare
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction, BigQuery, BigQuery Reservation, BigQuery Storage, Cloud Spanner, Cloud Storage, Cloud Storage API, Dataflow, Google Cloud, Cloud Storage JSON, Service Management, Service Usage.
-
Nella console Google Cloud, attiva Cloud Shell.
Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
-
Concedi i ruoli al tuo Account Google. Esegui questo comando una volta per ciascuno dei seguenti ruoli IAM:
- roles/apigee.admin
- roles/bigquery.user
- roles/bigquery.dataViewer
- roles/spanner.admin
- roles/spanner.databaseAdmin
- roles/resourcemanager.projectIamAdmin
- roles/serviceusage.serviceUsageConsumer
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE
- Sostituisci
PROJECT_IDcon l'ID progetto. - Sostituisci
EMAIL_ADDRESScon il tuo indirizzo email. - Sostituisci
ROLEcon ogni singolo ruolo.
- Se non hai ancora un account Apigee, configura Apigee per eseguire il provisioning di un'istanza Apigee. Il provisioning può richiedere fino a un'ora.
- Configura la tua organizzazione Apigee per consentire l'accesso esterno.
Se completi questa procedura e decidi di non conservare il deployment, puoi evitare la fatturazione continuativa eliminando le risorse che hai creato. Per ulteriori informazioni, consulta Eseguire la pulizia.
Creare un set di dati di suggerimenti per l'e-commerce utilizzando BigQuery ML
In questa sezione, utilizzerai query SQL standard in BigQuery ML per creare un modello ML, addestrarlo sui dati dei clienti in BigQuery e poi eseguirne il deployment.
I dati dei clienti che utilizzi provengono dal set di dati di esempio di Google Analytics, ospitato pubblicamente su BigQuery. Questo set di dati fornisce 12 mesi (agosto 2016-agosto 2017) di dati offuscati di Analytics 360 provenienti dal Google Merchandise Store, un vero negozio di e-commerce che vende merchandising con brand Google.
Non è necessario esportare i dati o creare una pipeline di addestramento e deployment dei modelli. BigQuery scala automaticamente per gestire le risorse di calcolo di cui hai bisogno.
Il modello ML che crei per questa soluzione utilizza la scomposizione matriciale, un metodo comune ed efficace per creare un sistema di suggerimenti basato sui dati delle preferenze degli utenti.
Elabora i dati di esempio
Quando utilizzi la fattorizzazione matriciale, valuti il feedback esplicito o implicito degli utenti per determinare le preferenze del cliente. Per utilizzare un feedback esplicito, il set di dati deve contenere i dati sulle preferenze di prodotto degli utenti, ad esempio le valutazioni a stelle comprese tra 1 e 5. Se non è disponibile un feedback esplicito, devi utilizzare altre metriche di comportamento per dedurre le preferenze dei clienti, ad esempio esaminare il tempo totale trascorso da un utente su una pagina dei dettagli del prodotto. Questa soluzione utilizza i dati sulla durata della sessione per dedurre le preferenze dei clienti.
Per addestrare il modello di fattorizzazione matriciale, è necessaria una tabella con colonne che
identificano il cliente, l'elemento valutato e la valutazione implicita. In questa sezione creerai una tabella di questo tipo con le colonne userid, itemId e session_duration. La colonna session_duration contiene la
durata della sessione dell'utente sulla pagina del prodotto dell'articolo in questione.
Per creare la tabella utilizzando i dati del set di dati campione di Analytics:
In Google Cloud Marketplace, vai alla pagina Esempio di analisi.
Fai clic su Visualizza set di dati. Si apre la pagina dell'area di lavoro di BigQuery SQL con il set di dati di esempio di Analytics selezionato.
Nella sezione Explorer, accanto al progetto, fai clic su Visualizza azioni, quindi su Crea set di dati.
Nella finestra di dialogo Crea set di dati visualizzata, segui questi passaggi:
- Nel campo ID set di dati, inserisci
bqml. - Nell'elenco Località dei dati, seleziona us (più regioni negli Stati Uniti).
- Fai clic su Crea set di dati.
- Nel campo ID set di dati, inserisci
Fai clic su Vai al set di dati e poi su Crea nuova query.
Nell'Editor query, crea una tabella contenente i dati di addestramento eseguendo la seguente istruzione SQL:
CREATE OR REPLACE TABLE bqml.aggregate_web_stats AS ( WITH durations AS ( --calculate pageview durations SELECT CONCAT(fullVisitorId,'-', CAST(visitNumber AS STRING),'-', CAST(hitNumber AS STRING) ) AS visitorId_session_hit, LEAD(time, 1) OVER ( PARTITION BY CONCAT(fullVisitorId,'-',CAST(visitNumber AS STRING)) ORDER BY time ASC ) - time AS pageview_duration FROM `bigquery-public-data.google_analytics_sample.ga_sessions_2017*`, UNNEST(hits) AS hit ), prodview_durations AS ( --filter for product detail pages only SELECT CONCAT(fullVisitorId,'-',CAST(visitNumber AS STRING)) AS userId, productSKU AS itemId, IFNULL(dur.pageview_duration, 1) AS pageview_duration, FROM `bigquery-public-data.google_analytics_sample.ga_sessions_2017*` t, UNNEST(hits) AS hits, UNNEST(hits.product) AS hits_product JOIN durations dur ON CONCAT(fullVisitorId,'-', CAST(visitNumber AS STRING),'-', CAST(hitNumber AS STRING)) = dur.visitorId_session_hit WHERE eCommerceAction.action_type = "2" ), aggregate_web_stats AS( --sum pageview durations by userId, itemId SELECT userId, itemId, SUM(pageview_duration) AS session_duration FROM prodview_durations GROUP BY userId, itemId ) SELECT * FROM aggregate_web_stats );La tabella
bqml.aggregate_web_statsviene creata e compilata con i dati di addestramento.Per visualizzare un esempio dei dati, nell'Editor query esegui la seguente istruzione SQL:
SELECT * FROM bqml.aggregate_web_stats LIMIT 10;
L'output mostra una tabella con una riga per ogni ID utente che include l'ID articolo visualizzato dall'utente e la durata della sessione. L'output è simile al seguente:
| Riga | userId | itemId | session_duration |
|---|---|---|---|
| 1 | 6703373209489429228-1 | GGOEAXXX0808 | 19523 |
| 2 | 868731560082458910-1 | GGOEAXXX0808 | 8312 |
| 3 | 4805474958539278422-1 | GGOEAXXX0808 | 62892 |
| 4 | 8353360074725418910-3 | GGOEAXXX0808 | 4883 |
| 5 | 8253742246691621007-2 | GGOEAXXX0808 | 10 |
| 6 | 7211254729136975568-1 | GGOEAXXX0808 | 96090 |
| 7 | 66777488032155805-1 | GGOEAXXX0808 | 3893 |
| 8 | 0804312527321649470-1 | GGOEAXXX0808 | 7539 |
| 9 | 2965429397557124425-1 | GGOEAXXX0808 | 21776 |
| 10 | 8459600677575627508-1 | GGOEAXXX0808 | 6265 |
Acquista slot flessibili
Se utilizzi i prezzi on demand per BigQuery, per addestrare un modello di fattorizzazione matriciale devi acquistare slot flessibili e poi creare prenotazioni e assegnazioni. Se utilizzi un modello a costo fisso con BigQuery, puoi saltare questa sezione e andare a Creare, addestrare ed eseguire il deployment del modello.
Per acquistare slot flessibili, devi avere un ruolo IAM che includa l'autorizzazione bigquery.reservations.create. Questa autorizzazione viene concessa al proprietario del progetto ed è inclusa nei ruoli IAM Amministratore BigQuery (roles/bigquery.admin) e Amministratore risorse BigQuery (roles/bigquery.resourceAdmin).
Nella console Google Cloud, vai alla pagina BigQuery:
Fai clic su Gestione della capacità e poi su Prenotazioni.
Se il sistema ti reindirizzerà alla pagina API BigQuery Reservation per abilitare l'API, fai clic su Abilita. In caso contrario, vai al passaggio successivo.
Nella scheda Prenotazioni, fai clic su Acquista slot.
Nella pagina Acquista slot:
- Nell'elenco Durata dell'impegno, seleziona Flex.
- Nell'elenco Località, seleziona us (più regioni negli Stati Uniti).
- Nell'elenco Numero di slot, seleziona 500.
- Tocca Avanti.
Nel campo Conferma di acquisto, digita
CONFIRMe fai clic su Acquisto.
Fai clic su Visualizza impegni slot.
Attendi fino a 20 minuti per il provisioning della capacità. Una volta eseguito il provisioning della capacità, la colonna Stato dell'impegno slot mostra .
Fai clic su Crea prenotazione, quindi imposta le seguenti opzioni:
- In Nome prenotazione, inserisci
model. - Nell'elenco Località, seleziona us (più regioni negli Stati Uniti).
- In Numero di slot, inserisci
500. - Fai clic su Salva. In questo modo tornerai alla pagina Prenotazioni.
- In Nome prenotazione, inserisci
Accanto alla prenotazione
model, nella colonna Azioni, seleziona Crea assegnazione.In Seleziona un'organizzazione, una cartella o un progetto, fai clic su Sfoglia.
Inserisci il nome del progetto che hai utilizzato per questa soluzione o selezionalo dall'elenco.
Fai clic su Seleziona, quindi su Crea.
Crea, addestra ed esegui il deployment del modello
Per creare, addestrare ed eseguire il deployment del modello di fattorizzazione matriciale:
- Nella pagina BigQuery della console Google Cloud, fai clic su Crea nuova query.
Esegui l'istruzione SQL
CREATE MODEL:CREATE OR REPLACE MODEL bqml.retail_recommender` OPTIONS(model_type='matrix_factorization', user_col='userId', item_col='itemId', rating_col='session_duration', feedback_type='implicit' ) AS SELECT * FROM bqml.aggregate_web_stats;
Al termine dell'addestramento, il deployment del modello addestrato viene eseguito come modello bqml.retail_recommender.
Utilizza il modello addestrato per fare previsioni
In questa sezione, per ottenere previsioni dal modello bqml.retail_recommender di cui è stato eseguito il deployment, utilizza la funzione SQL ML.RECOMMEND.
Nella pagina BigQuery della console Google Cloud, scrivi una query e ottieni previsioni che rappresentano i primi 5 suggerimenti per uno userId specificato:
DECLARE MY_USERID STRING DEFAULT "0824461277962362623-1"; SELECT * FROM ML.RECOMMEND(MODEL `bqml.retail_recommender`, (SELECT MY_USERID as userID) ) ORDER BY predicted_session_duration_confidence DESC LIMIT 5;L'output mostra una riga per l'affidabilità della durata della sessione prevista (maggiore è la durata migliore), l'ID utente associato e l'ID elemento visualizzato dall'utente. L'output è simile al seguente:
Riga predicted_session_duration_confidence userId itemId 1 29011,10454702254 0824461277962362623-1 GGOEGAAX0574 2 28212,99840462358 0824461277962362623-1 GGOEGDHQ015399 3 28126,79442866013 0824461277962362623-1 GGOEGETR014599 4 27303,60852083874 0824461277962362623-1 GGOEGAAX0338 5 25692,370609851147 0824461277962362623-1 GGOEGEFR024199 Per ottenere le 5 previsioni principali per tutti gli utenti, esegui la seguente istruzione SQL. L'istruzione genera molte righe, quindi l'output viene scritto in una tabella, quindi vengono recuperati i primi dieci record in modo da visualizzare un esempio dei dati.
-- Create output table of top 5 predictions CREATE OR REPLACE TABLE bqml.prod_recommendations AS ( WITH predictions AS ( SELECT userId, ARRAY_AGG(STRUCT(itemId, predicted_session_duration_confidence) ORDER BY predicted_session_duration_confidence DESC LIMIT 5) as recommended FROM ML.RECOMMEND(MODEL bqml.retail_recommender) GROUP BY userId ) SELECT userId, itemId, predicted_session_duration_confidence FROM predictions p, UNNEST(recommended) ); -- Show table SELECT * FROM bqml.prod_recommendations ORDER BY userId LIMIT 10;L'output mostra più ID utente, l'ID elemento visualizzato dall'utente e l'affidabilità prevista per la durata della sessione. L'output è simile al seguente:
Riga userId itemId predicted_session_duration_confidence 1 000170187170673177-6 GGOEGDHQ015399 15931,156936770309 2 000170187170673177-6 GGOEGAAX0574 20178,608474922632 3 000170187170673177-6 GGOEGAAX0338 20247,337545389437 4 000170187170673177-6 GGOEGETR014599 15524,355852692066 5 000170187170673177-6 GGOEGEFR024199 16443,307099088597 6 000338059556124978-1 GGOEGAAX0338 18143,067737280064 7 000338059556124978-1 GGOEGAAX0279 16531,718889063464 8 000338059556124978-1 GGOEGAAX0574 20916,672241880347 9 000338059556124978-1 GGOEGETR014599 16155,674211782945 10 000338059556124978-1 GGOEGEFR024199 18417,17554202264
Configura i dati di Spanner
Nelle sezioni seguenti, utilizzerai gcloud CLI e Maven. Puoi eseguire i comandi per entrambi gli strumenti da Cloud Shell. Non è richiesta alcuna installazione per utilizzare gli strumenti.
In Cloud Shell, clona il repository GitHut dei suggerimenti sui prodotti contenente il pacchetto proxy API Product-recommendations e gli script per la configurazione dei dati in un database Spanner:
git clone https://github.com/apigee/devrel/tree/main/references/product-recommendations cd product-recommendations-v1Creare l'account di servizio
datareadere assegnare ruoli IAM. L'account di servizio viene utilizzato per accedere ai dati in BigQuery e nel database Spanner dal proxy API.gcloud iam service-accounts create datareader --display-name="Data reader for BigQuery and Spanner Demo" gcloud iam service-accounts list | grep datareader gcloud iam service-accounts create datareader --display-name="Data reader for Apigee, BigQuery, and Spanner Demo" gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA" --role="roles/spanner.databaseUser" --quiet gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA" --role="roles/spanner.databaseReader" --quiet gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA" --role="roles/bigquery.dataViewer" --quiet gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA" --role="roles/bigquery.user" --quietImposta le variabili di ambiente:
# For Apigee export PROJECT_ID=APIGEE_PROJECT export ORG=$PROJECT_ID export ENV=eval export ENVGROUP_HOSTNAME=API_DOMAIN_NAME export SA=datareader@$PROJECT_ID.iam.gserviceaccount.com # For Cloud Spanner export SPANNER_INSTANCE=product-catalog export SPANNER_DATABASE=product-catalog-v1 export REGION=regional-us-east1Sostituisci quanto segue:
APIGEE_PROJECT: il nome del tuo progetto Apigee.API_DOMAIN_NAME: il nome host configurato nella pagina Amministrazione > Ambienti > Gruppi nella UI di Apigee.
Nella pagina BigQuery della console Google Cloud, seleziona la tabella
prod_recommendationse fai clic sulla scheda Anteprima per visualizzare i risultati.- Copia qualsiasi valore
userId. In Cloud Shell, imposta una variabile di ambiente:
export CUSTOMER_USERID=USER_IDSostituisci
USER_IDcon il valoreuserIdche hai copiato nel passaggio precedente.
- Copia qualsiasi valore
In Cloud Shell, visualizza i risultati dei suggerimenti di prodotto ordinati per il valore
CUSTOMER_USERIDspecificato:bq query --nouse_legacy_sql \ "SELECT * FROM \`$PROJECT_ID.bqml.prod_recommendations\` AS A where A.userid = \"$CUSTOMER_USERID\"" \ ORDER BY A.predicted_session_duration_confidence DESCL'output mostra un singolo ID utente, l'ID articolo visualizzato dall'utente e l'affidabilità prevista per la durata della sessione. L'output è simile al seguente:
+-----------------------+----------------+--------------------------------------------+ | userId | itemId | predicted_session_duration_confidence | +-----------------------+----------------+--------------------------------------------+ | 6929470170340317899-1 | GGOEGAAX0037 | 40161.10446942589 | | 6929470170340317899-1 | GGOEYDHJ056099 | 27642.28480729123 | | 6929470170340317899-1 | GGOEGAAX0351 | 27204.111219270915 | | 6929470170340317899-1 | GGOEGDWC020199 | 25863.861349754334 | | 6929470170340317899-1 | GGOEGAAX0318 | 24585.509088154067 | +-----------------------+----------------+--------------------------------------------+
Creare un database Spanner e importare i dati del catalogo dei prodotti
In Cloud Shell, crea un'istanza Spanner nella regione specificata, crea il database del catalogo dei prodotti e importa i dati:
./setup_spanner.shLo script utilizza la variabile di ambiente
CUSTOMER_USERIDe mostra le voci create.Il catalogo dei prodotti Spanner contiene solo gli elementi utilizzati nel passaggio di addestramento BigQuery per un utente specifico. Di conseguenza, se modifichi la variabile di ambiente
CUSTOMER_USERIDdopo aver creato i dati del catalogo dei prodotti nel database Spanner, devi eseguire nuovamente lo script shellsetup_spanner.shper ricompilare i dati.Verifica i dati nel database Spanner:
gcloud spanner databases execute-sql $SPANNER_DATABASE --sql='SELECT * FROM products'L'output mostra gli ID prodotto e le informazioni descrittive dal catalogo dei prodotti di Spanner, inclusi il prezzo e il percorso dell'immagine. L'output è simile al seguente:
productid name description price discount image GGOEGAAX0037 Aviator Sunglasses The ultimate sunglasses 42.42 0 products_Images/sunglasses.jpg GGOEGAAX0318 Bamboo glass jar Bamboo glass jar 19.99 0 products_Images/bamboo-glass-jar.jpg GGOEGAAX0351 Loafers Most comfortable loafers 38.99 0 products_Images/loafers.jpg GGOEGDWC020199 Hair dryer Hottest hair dryer 84.99 0 products_Images/hairdryer.jpg GGOEYDHJ056099 Coffee Mug Best Coffee Mug 4.2 0 products_Images/mug.jpg
Esegui il deployment del proxy Apigee
In questa sezione eseguirai un comando Maven per creare le risorse seguenti:
- Un proxy denominato
product-recommendations-v1 - Un prodotto API denominato
product-recommendations-v1-$ENV - Uno sviluppatore di app con nome
[email protected] - Un'app denominata
product-recommendations-v1-app-$ENV
Per creare le risorse, Maven utilizza il file pom.xml dal repository GitHub. Il file contiene le istruzioni e i passaggi di installazione.
La sezione del profilo del file pom.xml contiene valori per apigee.org,
apigee.env, api.northbound.domain, gcp.projectid, googletoken.email e
api.userid. Questi valori variano in base al progetto e vengono impostati tramite la riga di comando. L'esempio seguente mostra la sezione del file pom.xml che contiene i valori:
<profile>
<id>eval</id>
<properties>
<apigee.profile>eval</apigee.profile>
<apigee.org>${apigeeOrg}</apigee.org>
<apigee.env>${apigeeEnv}</apigee.env>
<api.northbound.domain>${envGroupHostname}</api.northbound.domain>
<gcp.projectid>${gcpProjectId}</gcp.projectid>
<apigee.googletoken.email>${googleTokenEmail}</apigee.googletoken.email>
<api.userid>${customerUserId}</api.userid>
</properties>
</profile>
Puoi impostare questi valori in precedenza, quando configuri i dati Spanner.
Per eseguire il deployment del proxy:
In Cloud Shell, installa il proxy e gli artefatti associati, quindi testa l'API:
mvn -P eval clean install -Dbearer=$(gcloud auth print-access-token) \ -DapigeeOrg=$ORG \ -DapigeeEnv=$ENV \ -DenvGroupHostname=$ENVGROUP_HOSTNAME \ -DgcpProjectId=$PROJECT_ID \ -DgoogleTokenEmail=$SA \ -DcustomerUserId=$CUSTOMER_USERIDL'output mostra l'esecuzione dei passaggi di installazione e i risultati delle chiamate API del test di integrazione. È presente una chiamata all'endpoint
/openapie un'altra all'endpoint/products. I risultati del test verificano che il proxy API sia stato installato, sottoposto a deployment e operativo. L'output mostra anche le credenziali dell'app, che puoi utilizzare per le successive chiamate di prova dell'API.
Testa l'API dei suggerimenti
In Cloud Shell, imposta una variabile di ambiente per la chiave API dell'app effettuando una chiamata curl all'API Apigee:
APIKEY=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" \ https://apigee.googleapis.com/v1/organizations/$ORG/developers/[email protected]/apps/product-recommendations-v1-app-$ENV \ | jq -r .credentials[0].consumerKey)Prendi nota del valore
APIKEY; hai bisogno di questa informazione se facoltativamente crei un'app AppSheet in un secondo momento.Per ottenere i risultati per il valore
CUSTOMER_USERIDspecificato al momento dell'installazione del proxy API, effettua una chiamata di prova:curl -s https://$ENVGROUP_HOSTNAME/v1/recommendations/products \ -H "x-apikey:$APIKEY" | jq
L'API definita dalla specifica OpenAPI (OAS) consente alla richiesta di specificare le seguenti intestazioni:
x-apikey: la chiave utente dell'app dello schema di sicurezza.x-userid: l'identificatore utente che effettua la richiesta. Se non viene fornito, questo valore viene impostato in modo predefinito sul valoreCUSTOMER_USERIDconfigurato nel proxy.cache-control: la quantità di tempo necessaria per memorizzare la risposta nella cache. Questa intestazione consente di memorizzare la risposta nella cache per 300 secondi o di sostituirla specificandono-cache.
Per modificare il valore CUSTOMER_USERID o controllare la memorizzazione nella cache, puoi impostare i valori dell'intestazione come mostrato nella seguente chiamata di esempio:
curl -s "https://$ENVGROUP_HOSTNAME/v1/recommendations/products" \
-H "x-apikey:$APIKEY" \
-H "x-userid:$CUSTOMER_USERID" \
-H "Cache-Control:no-cache" | jq
La risposta alla chiamata di esempio è simile alla seguente:
{
"products": [
{
"productid": "GGOEGAAX0037",
"name": "Aviator Sunglasses",
"description": "The ultimate sunglasses",
"price": "42.42",
"image": "products_Images/sunglasses.jpg"
},
{
"productid": "GGOEYDHJ056099",
"name": "Coffee Mug",
"description": "Best Coffee Mug",
"price": "4.2",
"image": "products_Images/mug.jpg"
},
{
"productid": "GGOEGAAX0351",
"name": "Loafers",
"description": "Most comfortable loafers",
"price": "38.99",
"image": "products_Images/loafers.jpg"
},
{
"productid": "GGOEGDWC020199",
"name": "Hairdryer",
"description": "Hotest hairdryer",
"price": "84.99",
"image": "products_Images/hairdryer.jpg"
},
{
"productid": "GGOEGAAX0318",
"name": "Bamboo glass jar",
"description": "Bamboo glass jar",
"price": "19.99",
"image": "products_Images/bamboo-glass-jar.jpg"
}
]
}
Criteri di Apigee
I criteri di Apigee elencati nelle sezioni seguenti vengono utilizzati nel pacchetto di proxy API.
Pre-flusso
- SpikeArrest
- Proteggi il servizio BigQuery di backend dai picchi di traffico.
- Quota
- Limita le richieste API in base all'applicazione consumer e allo sviluppatore. I limiti di limitazione sono configurati nel prodotto API.
- ResponseCache - URI
- Riduci le richieste al data warehouse BigQuery memorizzando nella cache la risposta dal servizio.
Flusso dei prodotti
- Assegna un messaggio - Crea una richiesta di query
- Imposta la richiesta HTTP con una query SQL per recuperare l'elenco di suggerimenti sui prodotti dal set di dati BigQuery.
- Norme relative a JavaScript e ExtractVariable
- Formatta i dati dal servizio BigQuery e crea un messaggio di risposta più intuitivo.
- LookupCache - Sessione Spanner
- Cerca l'ID sessione del database Spanner dalla cache di Apigee.
- ServiceCallout - Sessione Spanner
- Effettua una richiesta al servizio Spanner e crea una sessione di database se la cache di Apigee non ha un ID sessione o se l'ID è scaduto.
- PopulateCache - Sessione Spanner
- Inserisci l'ID sessione Spanner nella cache di Apigee.
- ServiceCallout - Ricerca nel catalogo dei prodotti
- Recupera i dettagli del prodotto dal database del catalogo dei prodotti di Spanner.
- JavaScript: formato dei dati di prodotto
- Crea un messaggio di risposta dell'API conforme all'OAS formattando i dati del database del catalogo dei prodotti.
Flusso OpenAPI
- Assegna un messaggio - JSON OAS
- Imposta la risposta JSON OAS per l'API.
(Facoltativo) Crea un'app AppSheet utilizzando Apigee come origine dati
Per mostrare suggerimenti sui prodotti agli utenti finali del sito web di e-commerce e agli utenti aziendali, puoi creare un'app AppSheet come mostrato in questa sezione.
Crea un account AppSheet
Crea un account AppSheet usando il tuo indirizzo email.
Creare un'origine dati
AppSheet utilizza il proxy API come origine dati per la nuova app. Per creare un'origine dati:
- Accedi ad AppSheet.
- Nella pagina Account personale, fai clic su Origini > Nuova origine dati.
- Nella finestra di dialogo Aggiungi una nuova origine dati, inserisci il nome del proxy
product-recommendations-v1e fai clic su Apigee. Nella finestra di dialogo Aggiungi informazioni di connessione all'API Apigee, imposta le seguenti opzioni:
- Seleziona Manuale.
- Nel campo Chiave API Apigee, inserisci la chiave API per la tua app,
che hai utilizzato per testare il proxy. Se non hai la chiave API, recuperala
in Cloud Shell eseguendo
echo $APIKEY. Nel campo Percorso base dell'API Apigee, inserisci quanto segue:
https://ENVGROUP_HOSTNAME/v1/recommendationsSostituisci ENVGROUP_HOSTNAME con il nome host configurato nella UI di Apigee per Amministrazione > Ambienti > Gruppi.
Nel campo Percorsi risorse API, inserisci il suffisso del percorso
products.Fai clic su Test.
Al termine dei test, fai clic su Autorizza accesso.
Dopo aver autorizzato l'accesso, nella console di AppSheet viene visualizzato un nuovo riquadro per product-recommendations-v1.
Crea l'app
- Vai alla pagina relativa all'app product-template di AppSheet.
- Fai clic su Copia e personalizza. Viene visualizzata la finestra di dialogo Clona l'app.
- Nel campo Nome app, inserisci il nome del proxy
product-recommendations-v1, quindi fai clic su Copia app. Attendi qualche momento per la creazione dell'app. - Nella pagina Ti diamo il benvenuto nella tua app, fai clic su Personalizza app. Per impostazione predefinita, l'app utilizza un'origine dati di esempio in un foglio Google.
Modifica l'origine dati in modo che corrisponda all'origine dati Apigee che hai creato in precedenza:
- Fai clic su + Nuova tabella e poi su Consigli sui prodotti v1.
- Nella finestra di dialogo Scegli un foglio/una tabella, seleziona prodotti.
- Nella finestra di dialogo Crea una nuova tabella, fai clic su Sola lettura e poi su Aggiungi questa tabella.
L'app viene mostrata con una scheda Prodotti 2 e una visualizzazione dati diversa. La nuova vista dati ha valori diversi per la descrizione e il prezzo di ogni articolo. Tieni presente che l'ordine degli elementi non corrisponde a quello delle previsioni.
Modifica l'ordine in cui gli elementi vengono restituiti dall'origine dati rimuovendo l'ordinamento predefinito di AppSheet:
- Nel menu di navigazione laterale, seleziona UX.
- Nella sezione Visualizzazioni principali, seleziona Prodotti 2.
- Nella sezione Opzioni di visualizzazione, accanto a Ordina per, elimina la voce nome, Crescente. Osserva che l'ordine visualizzato in AppSheet è ora lo stesso del risultato della chiamata API, con l'ultimo elemento della risposta in basso.
Salva l'app.
Facoltativamente, puoi eliminare la tabella Product e l'UX originali, nonché rinominare la tabella "Prodotti 2" e visualizzarla in "Product Recommendations".
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa procedura, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.
Elimina il progetto
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Elimina le singole risorse
Per evitare costi ricorrenti, elimina le prenotazioni di slot flessibili BigQuery, il set di dati BigQuery e il modello AI Platform.
Elimina le prenotazioni di slot flessibili BigQuery
- Nella pagina BigQuery della console Google Cloud, seleziona Gestione della capacità, quindi fai clic sulla scheda Prenotazioni.
- Apri la voce model.
- Accanto alla prenotazione, fai clic su Visualizza azioni, quindi fai clic su Elimina.
- Accanto alla voce model, fai clic su model e poi su model.
In Cloud Shell, elimina il deployment, il proxy e gli artefatti associati:
mvn -P eval process-resources -Dbearer=$(gcloud auth print-access-token) \ -DapigeeOrg=$ORG -DapigeeEnv=$ENV -Dskip.integration=true \ apigee-config:apps apigee-config:apiproducts apigee-config:developers -Dapigee.config.options=delete \ apigee-enterprise:deploy -Dapigee.options=cleanRimuovi le risorse Spanner:
./cleanup_spanner.sh
Elimina il set di dati BigQuery
- Nella sezione Risorse della pagina BigQuery della console Google Cloud, espandi il progetto che hai utilizzato per questa soluzione.
- Seleziona il set di dati bqml, quindi fai clic su Elimina set di dati.
- Nella finestra dell'overlay visualizzata, inserisci
bqmle fai clic su Elimina.
Elimina il modello AI Platform
Nella console Google Cloud, vai alla pagina Modelli di AI Platform.
Nell'elenco dei modelli, fai clic su rpm_bqml_model.
Nella pagina Dettagli modello, seleziona la casella di controllo per la versione V_1 (predefinita).
Fai clic su Altro e poi su Elimina.
Al termine dell'eliminazione della versione, fai clic su Indietro per tornare all'elenco dei modelli.
Seleziona la casella di controllo per il modello rpm_bqml_model.
Fai clic su Altro e poi su Elimina.
In Cloud Shell, elimina l'account di servizio:
gcloud iam service-accounts delete $SA
Passaggi successivi
- Scopri come chiamare i servizi Google Cloud dai proxy API Apigee.
- Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.