Workshop sulla modifica delle app

1. Introduzione

Ultimo aggiornamento: 1° novembre 2024

Come modernizziamo una vecchia applicazione PHP in Google Cloud?

(📽️ guarda un video introduttivo di 7 minuti su questo codelab)

È comune avere applicazioni legacy in esecuzione on-prem che devono essere modernizzate. Ciò significa renderli scalabili, sicuri e di cui è possibile eseguire il deployment in ambienti diversi.

In questo workshop imparerai a:

  1. Containerizzare l'applicazione PHP.
  2. Passa a un servizio di database gestito (Cloud SQL).
  3. Esegui il deployment su Cloud Run (l'alternativa zero-ops a GKE/Kubernetes).
  4. Proteggi l'applicazione con Identity and Access Management (IAM) e Secret Manager.
  5. Definisci una pipeline CI/CD tramite Cloud Build. Cloud Build può essere connesso al tuo repository Git ospitato su provider Git popolari come GitHub o GitLab e attivato, ad esempio, a ogni push nel ramo principale.
  6. Ospitare le immagini dell'applicazione su Cloud Storage. Questo risultato viene ottenuto tramite il montaggio e non è necessario alcun codice per modificare l'app.
  7. Introduci la funzionalità di AI generativa tramite Gemini, orchestrata tramite Cloud Functions (serverless).
  8. Acquisisci familiarità con gli SLO e con il funzionamento della tua app appena aggiornata.

Seguendo questi passaggi, puoi modernizzare gradualmente la tua applicazione PHP, migliorandone la scalabilità, la sicurezza e la flessibilità di deployment. Inoltre, il passaggio a Google Cloud ti consente di sfruttare la sua potente infrastruttura e i suoi servizi per garantire che la tua applicazione venga eseguita senza problemi in un ambiente cloud-native.

Riteniamo che ciò che imparerai seguendo questi semplici passaggi possa essere applicato alla tua applicazione e alla tua organizzazione con linguaggi/stack e casi d'uso diversi.

Informazioni sull'app

L'applicazione (codice, con licenza MIT) di cui eseguirai il fork è un'applicazione PHP 5.7 di base con autenticazione MySQL. L'idea principale dell'app è fornire una piattaforma in cui gli utenti possono caricare foto e gli amministratori hanno la possibilità di taggare le immagini inappropriate. L'applicazione ha due tabelle:

  • Utenti. Viene precompilato con gli amministratori. Nuove persone possono registrarsi.
  • Immagini. Include alcune immagini di esempio. Gli utenti che hanno eseguito l'accesso possono caricare nuove immagini. Aggiungeremo un po' di magia qui.

Il tuo obiettivo

Vogliamo modernizzare la vecchia applicazione per averla in Google Cloud. Sfrutteremo i suoi strumenti e servizi per migliorare la scalabilità, rafforzare la sicurezza, automatizzare la gestione dell'infrastruttura e integrare funzionalità avanzate come l'elaborazione delle immagini, il monitoraggio e l'archiviazione dei dati utilizzando servizi come Cloud SQL, Cloud Run, Cloud Build, Secret Manager e altri ancora.

445f7a9ae37e9b4d.png

Ma soprattutto, vogliamo farlo passo dopo passo, in modo che tu possa apprendere il processo di pensiero alla base di ogni passaggio. Di solito, ogni passaggio sblocca nuove possibilità per i successivi (ad esempio: moduli 2 -> 3 e 6 -> 7).

Hai ancora dubbi? Guarda questo video di 7 minuti su YouTube.

Che cosa ti serve

  • Un computer con un browser, connesso a internet.
  • Alcuni crediti GCP. Consulta il passaggio successivo.
  • Utilizzerai Cloud Shell. Include tutti i comandi preinstallati di cui avrai bisogno e un IDE.
  • Account GitHub. Ti serve per creare un branch del codice originale 🧑🏻‍💻 gdgpescara/app-mod-workshop con il tuo repository Git. Questo è necessario per avere la tua pipeline CI/CD (commit automatico -> build -> deployment)

Puoi trovare soluzioni di esempio qui:

Questo workshop è progettato per essere completato su Cloud Shell (su un browser).

Tuttavia, puoi anche provare a farlo dal tuo computer locale.

2. Configurazione del credito e fork

6dafc658860c0ce5.png

Riscatta il credito GCP e configura l'ambiente GCP [facoltativo]

Per eseguire questo workshop, devi disporre di un account di fatturazione con un po' di credito. Per iniziare, utilizza i crediti del banner nella parte superiore di questo codelab. Se hai già un collegamento a un account di fatturazione, puoi saltare questo passaggio.

Al termine, apri la console Google Cloud e crea un nuovo progetto facendo clic sul selettore di progetti nel menu a discesa in alto a sinistra, dove viene visualizzato "Nessuna organizzazione". Vedi di seguito

bd7548f78689db0b.png

Se non ne hai uno, crea un nuovo progetto come mostrato nello screenshot di seguito. Nell'angolo in alto a destra è presente l'opzione "NUOVO PROGETTO".

6c82aebcb9f5cd47.png

Assicurati di collegare il nuovo progetto all'account di fatturazione di prova di GCP come segue.

f202527d254893fb.png

È tutto pronto per utilizzare Google Cloud. Se sei un principiante o vuoi semplicemente fare tutto in un ambiente cloud, puoi accedere a Cloud Shell e al relativo editor tramite il seguente pulsante nell'angolo in alto a sinistra, come mostrato di seguito.

7d732d7bf0deb12e.png

Assicurati che il nuovo progetto sia selezionato in alto a sinistra:

Non selezionato (non valido):

c2ffd36a781b276a.png

Selezionato (buono):

594563c158f4f590.png

Crea un fork dell'app da GitHub

  1. Vai all'app demo: https://github.com/gdgpescara/app-mod-workshop
  2. Fai clic su 🍴 Fork.
  3. Se non hai un account GitHub, devi crearne uno nuovo.
  4. Apporta le modifiche che preferisci.

734e51bfc29ee5df.png

  1. Clona il codice dell'app utilizzando
  2. git clone https://github.com/YOUR-GITHUB-USER/YOUR-REPO-NAME
  1. Apri la cartella del progetto clonato con il tuo editor preferito. Se scegli Cloud Shell, puoi farlo facendo clic su "Apri editor" come mostrato di seguito.

40f5977ea4c1d1cb.png

Hai tutto ciò che ti serve con l'editor di Google Cloud Shell, come mostrato nella figura seguente

a4e5ffb3e9a35e84.png

Puoi farlo visivamente facendo clic su "Apri cartella" e selezionando la cartella, probabilmente app-mod-workshop nella tua cartella home.

3. Modulo 1: crea un'istanza SQL

645902e511a432a6.png

Crea l'istanza Google Cloud SQL

La nostra app PHP si connetterà a un database MySQL, quindi dobbiamo replicarlo in Google Cloud per una migrazione senza problemi. Cloud SQL è la soluzione perfetta, in quanto ti consente di eseguire un database MySQL completamente gestito nel cloud. Ecco i passaggi da seguire:

  1. Vai alla pagina Cloud SQL: https://console.cloud.google.com/sql/instances
  2. Fai clic su "Crea istanza".
  3. Abilita API (se necessario). L'operazione potrebbe richiedere alcuni secondi.
  4. Scegli MySQL.
  5. (Stiamo cercando di farti avere la versione più economica, in modo che duri più a lungo):
  • Versione: Enterprise
  • Preset: development (abbiamo provato Sandbox, ma non ha funzionato)
  • Versione MySQL: 5.7 (wow, un tuffo nel passato!)
  1. ID istanza: scegli appmod-phpapp (se lo modifichi, ricordati di modificare di conseguenza anche gli script e le soluzioni futuri).
  2. Password: quella che preferisci, ma annotala come CLOUDSQL_INSTANCE_PASSWORD
  3. Regione: mantieni la stessa regione che hai scelto per il resto dell'app (ad es. Milano = europe-west8)
  4. Disponibilità a livello di zona: Zona singola (stiamo risparmiando denaro per la demo)

Fai clic sul pulsante Crea istanza per eseguire il deployment del database Cloud SQL; ⌛ il completamento richiede circa 10 minuti⌛. Nel frattempo, continua a leggere la documentazione; puoi anche iniziare a risolvere il modulo successivo ("Containerizza la tua app PHP"), poiché non ha dipendenze da questo modulo nella prima parte (fino a quando non correggi la connessione al DB).

Nota: Questa istanza dovrebbe costarti circa 7$/giorno. Assicurati di disattivarlo dopo il workshop.

Crea il database image_catalog e l'utente in Cloud SQL

Il progetto App include una cartella db/ che contiene due file SQL:

  1. 01_schema.sql: contiene il codice SQL per creare due tabelle che contengono i dati di utenti e immagini.
  2. 02_seed.sql: contiene il codice SQL per inserire i dati nelle tabelle create in precedenza.

Questi file verranno utilizzati in un secondo momento, una volta creato il database image_catalog. Per farlo, segui questi passaggi:

  1. Apri l'istanza e fai clic sulla scheda Database:
  2. fai clic su "Crea database"
  3. chiamalo image_catalog (come nella configurazione dell'app PHP).

997ef853e5ebd857.png

Poi creiamo l'utente del database. In questo modo possiamo autenticarci nel database image_catalog.

  1. Ora fai clic sulla scheda Utenti.
  2. Fai clic su "Aggiungi account utente".
  3. Utente: creiamone uno:
  • Nome utente: appmod-phpapp-user
  • Password: scegli una password che puoi ricordare o fai clic su "Genera".
  • Mantieni "Consenti qualsiasi host (%)".
  1. fai clic su AGGIUNGI.

Apri il database a IP noti.

Tieni presente che tutti i database in Cloud SQL nascono "isolati". Devi configurare esplicitamente una rete da cui sia possibile accedere.

  1. Fai clic sulla tua istanza
  2. Apri il menu "Connessioni".
  3. Fai clic sulla scheda "Networking".
  4. Fai clic su "Reti autorizzate". Ora aggiungi una rete (ovvero una subnet).
  • Per il momento, scegliamo un'impostazione rapida ma NON SICURA per consentire all'app di funzionare. In seguito, potresti volerla limitare agli IP di cui ti fidi:
  • Nome: "Everyone in the world - INSECURE".
  • Rete: "0.0.0.0/0" (Nota: questa è la parte NON SICURA!)
  • Fai clic su FINE.
  1. Fai clic su Salva.

Il risultato dovrebbe essere simile a questo:

5ccb9062a7071964.png

Nota: Questa soluzione è un buon compromesso per completare il workshop in O(ore). Tuttavia, consulta il documento SICUREZZA per proteggere la tua soluzione per la produzione.

È il momento di testare la connessione al database.

Vediamo se l'utente image_catalog che abbiamo creato in precedenza funziona.

Accedi a "Cloud SQL Studio" all'interno dell'istanza e inserisci il database, l'utente e la password per l'autenticazione, come mostrato di seguito:

d56765c6154c11a4.png

Ora che hai eseguito l'accesso, puoi aprire l'editor SQL e procedere alla sezione successiva.

Importa il database dal codebase

Utilizza l'editor SQL per importare le tabelle image_catalog con i relativi dati. Copia il codice SQL dai file nel repository (01_schema.sql e poi 02_seed.sql) ed eseguili uno dopo l'altro in ordine sequenziale.

Dopodiché, dovresti visualizzare due tabelle in image_catalog, ovvero users e images, come mostrato di seguito:

65ba01e4c6c2dac0.png

Puoi testarlo eseguendo questo comando nell'editor: select * from images;

Assicurati inoltre di annotare l'indirizzo IP pubblico dell'istanza Cloud SQL, che ti servirà in seguito. Per ottenere l'IP, vai alla pagina principale dell'istanza Cloud SQL nella pagina Panoramica. (Panoramica > Connettiti a questa istanza > Indirizzo IP pubblico).

4. Modulo 2: containerizza la tua app PHP

e7f0e9979d8805f5.png

Vogliamo creare questa app per il cloud.

Ciò significa pacchettizzare il codice in un file ZIP che contiene tutte le informazioni per eseguirlo nel cloud.

Esistono diversi modi per pacchettizzarlo:

  • Docker. Molto popolare, ma piuttosto complessa da configurare correttamente.
  • Buildpack. Meno popolare, ma tende a "indovinare automaticamente" cosa creare e cosa eseguire. Spesso funziona e basta.

Nel contesto di questo workshop, supponiamo che tu utilizzi Docker.

Se hai scelto di utilizzare Cloud Shell, questo è il momento di riaprirlo (fai clic in alto a destra nella console Cloud).

ec6a6b90b39e03e.png

In questo modo, dovrebbe aprirsi una comoda shell nella parte inferiore della pagina, dove dovresti aver eseguito il fork del codice nel passaggio di configurazione.

6999b906c0dedeb7.png

Docker

Se vuoi avere il controllo, questa è la soluzione giusta per te. Questo è utile quando devi configurare librerie specifiche e inserire determinati comportamenti non ovvi (un chmod nei caricamenti, un eseguibile non standard nella tua app e così via).

Poiché l'obiettivo finale è eseguire il deployment della nostra applicazione containerizzata su Cloud Run, consulta la seguente documentazione. Come faresti il backporting da PHP 8 a PHP 5.7? Forse puoi usare Gemini per farlo. In alternativa, puoi utilizzare questa versione preconfigurata:

# Use the official PHP image: https://hub.docker.com/_/php
FROM php:5.6-apache

# Configure PHP for Cloud Run.
# Precompile PHP code with opcache.
# Install PHP's extension for MySQL
RUN docker-php-ext-install -j "$(nproc)" opcache mysqli pdo pdo_mysql && docker-php-ext-enable pdo_mysql

RUN set -ex; \
  { \
    echo "; Cloud Run enforces memory & timeouts"; \
    echo "memory_limit = -1"; \
    echo "max_execution_time = 0"; \
    echo "; File upload at Cloud Run network limit"; \
    echo "upload_max_filesize = 32M"; \
    echo "post_max_size = 32M"; \
    echo "; Configure Opcache for Containers"; \
    echo "opcache.enable = On"; \
    echo "opcache.validate_timestamps = Off"; \
    echo "; Configure Opcache Memory (Application-specific)"; \
    echo "opcache.memory_consumption = 32"; \
  } > "$PHP_INI_DIR/conf.d/cloud-run.ini"

# Copy in custom code from the host machine.
WORKDIR /var/www/html

COPY . .

# Setup the PORT environment variable in Apache configuration files: https://cloud.google.com/run/docs/reference/container-contract#port
ENV PORT=8080

# Tell Apache to use 8080 instead of 80.
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

# Note: This is quite insecure and opens security breaches. See last chapter for hardening ideas.
# Uncomment at your own risk:
#RUN chmod 777 /var/www/html/uploads/

# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://github.com/docker-library/docs/blob/master/php/README.md#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

# Expose the port
EXPOSE 8080

L'ultima versione di Dockerfile è disponibile qui.

Per testare la nostra applicazione localmente, dobbiamo modificare il file config.php in modo che la nostra app PHP si connetta al database MYSQL disponibile su Google Cloud SQL. In base a ciò che hai configurato in precedenza, riempi gli spazi vuoti:

<?php
// Database configuration
$db_host = '____________';
$db_name = '____________';
$db_user = '____________';
$db_pass = '____________';

try {
    $pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Errore di connessione: " . $e->getMessage());
}

session_start();
?>
  • DB_HOST è l'indirizzo IP pubblico di Cloud SQL, che puoi trovare nella console SQL:

bd27071bf450a8d0.png

  • DB_NAME non deve essere modificato: image_catalog
  • DB_USER deve essere appmod-phpapp-user
  • DB_PASS è un'opzione che hai scelto. Configuralo tra virgolette singole e utilizza l'escape, se necessario.

Inoltre, non esitare a tradurre i pochi brani in italiano 🇮🇹 in inglese con l'aiuto di Gemini!

Ok, ora che hai il Dockerfile e hai configurato la tua app PHP per connetterti al tuo DB, proviamo.

Se non l'hai ancora fatto, installa Docker (link). Non è necessario se utilizzi Cloud Shell (non è fantastico?).

Ora prova a creare ed eseguire la tua app PHP containerizzata con i comandi docker build e run appropriati.

# Build command - don't forget the final . This works if Dockerfile is inside the code folder:
$ docker build -t my-php-app-docker .   

# Local Run command: most likely ports will be 8080:8080
$ docker run -it -p <CONTAINER_PORT>:<LOCAL_MACHINE_PORT> my-php-app-docker

Se tutto funziona, dovresti riuscire a visualizzare la seguente pagina web quando ti connetti all'host locale. Ora che l'app è in esecuzione sulla porta 8080, fai clic sull'icona "Anteprima web" (un browser con un occhio) e poi su Anteprima sulla porta 8080 (o su "Cambia porta" per qualsiasi altra porta).

33a24673f4550454.png

Test del risultato nel browser

Ora la tua applicazione dovrebbe avere un aspetto simile al seguente:

2718ece96b1f18b6.png

Se accedi con Admin/admin123, dovresti vedere qualcosa di simile.

68b62048c2e86aea.png

Ottimo! A parte il testo in italiano, funziona. 🎉🎉🎉

Se la dockerizzazione è corretta, ma le credenziali del database sono errate, potresti visualizzare un messaggio simile al seguente:

e22f45b79bab86e1.png

Riprova, ci sei quasi.

Salvataggio in Artifact Registry [facoltativo]

A questo punto, dovresti avere un'applicazione PHP containerizzata funzionante pronta per il deployment nel cloud. Ora abbiamo bisogno di uno spazio nel cloud per archiviare la nostra immagine Docker e renderla accessibile per il deployment nei servizi Google Cloud come Cloud Run. Questa soluzione di archiviazione si chiama Artifact Registry, un servizio Google Cloud completamente gestito progettato per l'archiviazione di artefatti delle applicazioni, tra cui immagini container Docker, pacchetti Maven, moduli npm e altro ancora.

Creiamo un repository in Google Cloud Artifact Registry utilizzando il pulsante appropriato.

e1123f0c924022e6.png

Scegli un nome valido, il formato e la regione adatti per l'archiviazione degli artefatti.

4e516ed209c470ee.png

Torna al tuo ambiente di sviluppo locale, aggiungi un tag ed esegui il push dell'immagine container dell'app nel repository Artifact Registry appena creato. Per farlo, esegui i seguenti comandi.

  • docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
  • docker push TARGET_IMAGE[:TAG]

Il risultato dovrebbe essere simile allo screenshot seguente.

1e498feb4e88be9f.png

Evviva 🎉🎉🎉 Puoi passare al livello successivo. Prima di allora, magari dedica 2 minuti a provare a caricare/accedere/disconnetterti e a familiarizzare con gli endpoint dell'app.Ti serviranno in seguito.

Possibili errori

Se ricevi errori di containerizzazione, prova a utilizzare Gemini per spiegare e correggere l'errore, fornendo:

  • Il tuo Dockerfile attuale
  • L'errore ricevuto
  • [Se necessario] Il codice PHP in esecuzione.

Autorizzazioni di caricamento. Prova anche l'endpoint /upload.php e prova a caricare un'immagine. Potresti ricevere l'errore riportato di seguito. In questo caso, devi correggere chmod/chown in Dockerfile.

Warning: move_uploaded_file(uploads/image (3).png): failed to open stream: Permission denied in /var/www/html/upload.php on line 11

PDOException "could not find driver" (o "Errore di connessione: could not find driver"). Assicurati che il Dockerfile contenga le librerie PDO corrette per mysql (pdo_mysql) per connetterti al database. Trova ispirazione dalle soluzioni qui.

Impossibile inoltrare la richiesta a un backend. Impossibile connettersi a un server sulla porta 8080. Ciò significa che probabilmente stai esponendo la porta sbagliata. Assicurati di esporre la porta da cui Apache/Nginx stanno effettivamente pubblicando. Non è un'operazione semplice. Se possibile, prova a utilizzare la porta 8080 (semplifica la vita con Cloud Run). Se vuoi mantenere la porta 80 (ad esempio, perché Apache lo richiede), utilizza un comando diverso per eseguirlo:

$ docker run -it -p 8080:80 # force 80

# Use the PORT environment variable in Apache configuration files.

# https://cloud.google.com/run/docs/reference/container-contract#port

RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

5. Modulo 3: esegui il deployment dell'app in Cloud Run

9ffca42774f6c5d1.png

Perché scegliere Cloud Run?

Domanda legittima. Anni fa, avresti sicuramente scelto Google App Engine.

In poche parole, oggi Cloud Run ha uno stack tecnologico più recente, è più facile da implementare, più economico e fa lo scale down fino a 0 quando non lo utilizzi. Grazie alla sua flessibilità nell'eseguire qualsiasi container stateless e alla sua integrazione con vari servizi Google Cloud, è ideale per il deployment di microservizi e applicazioni moderne con un overhead minimo e la massima efficienza.

Più nello specifico, Cloud Run è una piattaforma completamente gestita di Google Cloud che consente di eseguire applicazioni containerizzate stateless in un ambiente serverless. Gestisce automaticamente tutta l'infrastruttura, eseguendo lo scale up da zero per soddisfare il traffico in entrata e lo scale down quando è inattiva, il che la rende conveniente ed efficiente. Cloud Run supporta qualsiasi linguaggio o libreria, purché sia pacchettizzato in un container, consentendo una grande flessibilità nello sviluppo. Si integra bene con altri servizi Google Cloud ed è adatto per la creazione di microservizi, API, siti web e applicazioni basate su eventi senza dover gestire l'infrastruttura server.

Prerequisiti

Per completare questa attività, devi aver installato gcloud sulla tua macchina locale. In caso contrario, consulta le istruzioni qui. Se invece utilizzi Google Cloud Shell, non devi fare nulla.

Prima del deployment…

Se lavori nel tuo ambiente locale, esegui l'autenticazione su Google Cloud con il seguente comando:

  • $ gcloud auth login –update-adc # not needed in Cloud Shell

In questo modo, l'autenticazione dovrebbe avvenire tramite un accesso OAuth nel browser. Assicurati di accedere tramite Chrome con lo stesso utente (ad es. vattelapesca@gmail.com) che ha eseguito l'accesso a Google Cloud con la fatturazione abilitata.

Abilita l'API Cloud Run con il seguente comando:

  • $ gcloud services enable run.googleapis.com cloudbuild.googleapis.com

A questo punto, tutto è pronto per il deployment in Cloud Run.

Esegui il deployment della tua app in Cloud Run tramite gcloud

Il comando che ti consente di eseguire il deployment dell'app su Cloud Run è gcloud run deploy. Esistono diverse opzioni da impostare per raggiungere il tuo obiettivo. Il set minimo di opzioni (che puoi fornire tramite riga di comando o che lo strumento ti chiederà con un prompt interattivo) è il seguente:

  1. Nome del servizio Cloud Run di cui vuoi eseguire il deployment per la tua app. Un servizio Cloud Run ti restituirà un URL che fornisce un endpoint alla tua app.
  2. Regione Google Cloud in cui verrà eseguita l'app. (--region REGIONE)
  3. Immagine container che racchiude la tua app.
  4. Variabili di ambiente che l'app deve utilizzare durante l'esecuzione.
  5. Il flag allow-unauthenticated, che consente a chiunque di accedere alla tua app senza ulteriore autenticazione.

Consulta la documentazione (o scorri verso il basso per una possibile soluzione) per scoprire come applicare questa opzione alla riga di comando.

Il deployment richiederà alcuni minuti. Se tutto è corretto, dovresti vedere qualcosa di simile nella console Google Cloud.

ef1029fb62f8de81.pngf7191d579c21ca3e.png

Fai clic sull'URL fornito da Cloud Run e testa l'applicazione. Una volta eseguita l'autenticazione, dovresti vedere qualcosa di simile a questo.

d571a90cd5a373f9.png

"gcloud run deploy" senza argomenti

Potresti aver notato che gcloud run deploy ti fa le domande giuste e compila gli spazi vuoti che hai lasciato. È fantastico!

Tuttavia, in alcuni moduli aggiungeremo questo comando a un trigger di Cloud Build, quindi non possiamo permetterci domande interattive. Dobbiamo compilare ogni opzione del comando. Quindi vuoi creare la gcloud run deploy --option1 blah --foo bar --region your-fav-region d'oro. Come procedi?

  1. Ripeti i passaggi 2, 3 e 4 finché gcloud non smette di fare domande:
  2. [LOOP] gcloud run deploy con opzioni trovate finora
  3. [LOOP] systems ask for option X
  4. [LOOP] Cerca nella documentazione pubblica come configurare X dall'interfaccia a riga di comando aggiungendo l'opzione --my-option [my-value].
  5. Torna al passaggio 2, a meno che gcloud non venga completato senza ulteriori domande.
  6. Questo gcloud run deploy BLA BLA BLA è fantastico! Salva il comando da qualche parte, ti servirà in un secondo momento per il passaggio di Cloud Build.

Una possibile soluzione è disponibile qui. La documentazione è disponibile qui.

Evviva 🎉🎉🎉 Hai eseguito il deployment della tua app in Google Cloud, completando il primo passaggio della modernizzazione.

6. Modulo 4: pulisci la password con Secret Manager

95cd57b03b4e3c73.png

Nel passaggio precedente, siamo riusciti a eseguire il deployment e l'esecuzione della nostra app in Cloud Run. Tuttavia, l'abbiamo fatto con una best practice di sicurezza errata: fornendo alcuni secret in chiaro.

Prima iterazione: aggiorna il file config.php per utilizzare ENV

Forse avrai notato che abbiamo inserito la password del database direttamente nel codice del file config.php. Questo va bene per i test e per verificare se l'app funziona. Tuttavia, non puoi eseguire il commit o utilizzare un codice di questo tipo in un ambiente di produzione. La password (e altri parametri di connessione al DB) deve essere letta dinamicamente e fornita all'app in fase di runtime. Modifica il file config.php in modo che legga i parametri del database dalle variabili ENV. Se non va a buon fine, ti consigliamo di impostare i valori predefiniti. In questo modo, se non riesci a caricare ENV, l'output della pagina ti indicherà se vengono utilizzati i valori predefiniti. Compila gli spazi vuoti e sostituisci il codice nel file config.php.

<?php
// Database configuration with ENV variables. Set default values as well 
$db_host = getenv('DB_HOST') ?: 'localhost';
$db_name = getenv('DB_NAME') ?: 'image_catalog';
$db_user = getenv('DB_USER') ?: 'appmod-phpapp-user';
$db_pass = getenv('DB_PASS') ?: 'wrong_password';
// Note getenv() is PHP 5.3 compatible
try {
    $pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Errore di connessione: " . $e->getMessage());
}

session_start();
?>

Poiché la tua app è containerizzata, devi fornire un modo per fornire le variabili ENV all'app. Puoi farlo in diversi modi:

  • In fase di build, nel Dockerfile. Aggiungi al Dockerfile precedente i 4 parametri utilizzando la sintassi ENV DB_VAR=ENV_VAR_VALUE. In questo modo verranno impostati i valori predefiniti, che possono essere sostituiti in fase di runtime. Ad esempio, "DB_NAME" e "DB_USER" potrebbero essere impostati qui e in nessun altro posto.
  • In fase di esecuzione. Puoi configurare queste variabili per Cloud Run, sia dall'interfaccia a riga di comando che dall'interfaccia utente. Questo è il posto giusto per inserire tutte e quattro le variabili (a meno che tu non voglia mantenere i valori predefiniti impostati nel Dockerfile).

In localhost, potresti voler inserire le variabili ENV in un file .env (controlla la cartella solutions).

Assicurati anche che .env sia aggiunto al tuo .gitignore : non vuoi inviare i tuoi secret a GitHub.

echo .env >> .gitignore

Dopodiché, puoi testare l'istanza localmente:

docker run -it -p 8080:8080 --env-file .env my-php-app-docker

Ora hai ottenuto quanto segue:

  1. La tua app leggerà la variabile in modo dinamico dal tuo ambiente
  2. Hai migliorato la sicurezza rimuovendo la password del database dal codice.

Ora puoi eseguire il deployment di una nuova revisione in Cloud Run. Passiamo alla UI e impostiamo manualmente le variabili di ambiente:

  • Vai alla pagina https://console.cloud.google.com/run
  • Fai clic sulla tua app.
  • Fai clic su "Modifica ed esegui il deployment di una nuova revisione".
  • Nella prima scheda "Container", fai clic sulla scheda inferiore "Variabili e secret".
  • Fai clic su "+ Aggiungi variabile" e aggiungi tutte le variabili necessarie. Dovresti ottenere un risultato simile al seguente:

7a5fbfa448544d3.pngf2780c35585388ca.png

È perfetto? No, il tuo PASS è ancora visibile alla maggior parte degli operatori. Questa situazione può essere mitigata con Secret Manager di Google Cloud.

Seconda iterazione: Secret Manager

Le tue password sono scomparse dal tuo codice: vittoria! Ma aspetta, siamo al sicuro?

Le tue password sono ancora visibili a chiunque abbia accesso alla console Google Cloud. Infatti, se accedi al file di deployment YAML di Cloud Run, potrai recuperarlo. In alternativa, se provi a modificare o eseguire il deployment di una nuova revisione di Cloud Run, la password è visibile nella sezione Variabili e secret, come mostrato negli screenshot di seguito.

Google Cloud Secret Manager è un servizio sicuro e centralizzato per la gestione di informazioni sensibili come chiavi API, password, certificati e altri secret.

Ti consente di archiviare, gestire e accedere ai secret con autorizzazioni granulari e una crittografia efficace. Integrato con Identity and Access Management (IAM) di Google Cloud, Secret Manager ti consente di controllare chi può accedere a secret specifici, garantendo la sicurezza dei dati e la conformità legale.

Supporta inoltre la rotazione e il controllo delle versioni automatici dei secret, semplificando la gestione del ciclo di vita dei secret e migliorando la sicurezza nelle applicazioni nei servizi Google Cloud.

Per accedere a Secret Manager, vai dal menu a tre linee ai servizi di Sicurezza e trovalo nella sezione Protezione dei dati, come mostrato nello screenshot di seguito.

6df83a1c3cb757f6.png

Abilita l'API Secret Manager come mostrato nell'immagine seguente.

a96c312e2c098db1.png

  • Ora fai clic su "Crea un secret". Chiamiamolo in modo razionale:
  • Nome: php-amarcord-db-pass
  • Valore del secret: "la tua password del DB" (ignora la parte "carica file").
  • Annota questo link segreto, che dovrebbe essere simile a projects/123456789012/secrets/php-amarcord-db-pass. Questo è il puntatore univoco al tuo secret (per Terraform, Cloud Run e altri). Il numero è il numero di progetto univoco.

Suggerimento: Prova a usare convenzioni di denominazione coerenti per i tuoi segreti, specializzandoti da sinistra a destra, ad esempio: cloud-devrel-phpamarcord-dbpass

  • Organizzazione (con l'azienda)
  • Team (all'interno dell'organizzazione)
  • Applicazione (all'interno del team)
  • Nome della variabile (all'interno dell'app)

In questo modo, potrai utilizzare espressioni regolari semplici per trovare tutti i secret di una singola app.

Crea una nuova revisione Cloud Run

Ora che abbiamo un nuovo secret, dobbiamo eliminare la variabile di ambiente DB_PASS e sostituirla con il nuovo secret. Pertanto:

  • Accesso a Cloud Run utilizzando la console Google Cloud
  • Scegli l'app.
  • Fai clic su "Modifica ed esegui il deployment di una nuova revisione".
  • individua la scheda "Variabili e secret".
  • Utilizza il pulsante "+ Fai riferimento a un secret" per reimpostare la variabile di ambiente DB_PASS.
  • Utilizza lo stesso "DB_PASS" per i secret di riferimento e utilizza l'ultima versione.

9ed4e35be7654dcb.png

Al termine, dovresti ricevere il seguente errore

da0ccd7af39b04ed.png

Prova a capire come risolvere il problema. Per risolvere il problema, devi accedere alla sezione IAM e amministrazione e modificare le autorizzazioni di concessione. Buon debug!

Una volta individuato il problema, torna a Cloud Run e rifai il deployment di una nuova revisione. Il risultato dovrebbe essere simile alla seguente figura:

e89f9ca780169b6b.png

Suggerimento: la Developer Console (UI) è molto utile per segnalare i problemi relativi alle autorizzazioni. Prenditi del tempo per esplorare tutti i link delle tue entità Cloud.

7. Modulo 5: configura la pipeline CI/CD con Cloud Build

ba49b033c11be94c.png

Perché una pipeline CI/CD?

A questo punto, dovresti aver digitato gcloud run deploy alcune volte, magari rispondendo alla stessa domanda più e più volte.

Non vuoi più eseguire manualmente il deployment della tua app con gcloud run deploy? Non sarebbe fantastico se la tua app potesse eseguire automaticamente il deployment ogni volta che esegui il push di una nuova modifica nel repository Git?

Per utilizzare una pipeline CI/CD, sono necessarie due cose:

  1. Un repository Git personale: per fortuna, dovresti aver già eseguito il fork del repository del workshop nel tuo account GitHub nel passaggio 2. In caso contrario, torna indietro e completa il passaggio. Il repository con fork dovrebbe avere il seguente aspetto: https://github.com/<YOUR_GITHUB_USER>/app-mod-workshop
  2. Cloud Build. Questo servizio straordinario ed economico ti consente di configurare automazioni di build per quasi tutto: Terraform, app containerizzate con Docker…

Questa sezione si concentra sulla configurazione di Cloud Build.

Entra in Cloud Build

Per farlo, utilizzeremo Cloud Build:

  • creare il codice sorgente (con Dockerfile). Immagina che sia un "grande file ZIP" che contiene tutto ciò che serve per creare ed eseguire l'applicazione (il tuo "artefatto di build").
  • esegui il push di questo artefatto in Artifact Registry (AR).
  • Quindi esegui un deployment da AR a Cloud Run per l'app "php-amarcord"
  • In questo modo verrà creata una nuova versione ("revisione") dell'app esistente (pensa a un livello con il nuovo codice) e la configureremo in modo da deviare il traffico verso la nuova versione se il push va a buon fine.

Ecco un esempio di alcune build per la mia app php-amarcord:

f30f42d4571ad5e2.png

Come facciamo tutto questo?

  1. Creando un file YAML perfetto: cloudbuild.yaml
  2. Creando un trigger di Cloud Build.
  3. Connettendoci al nostro repository GitHub tramite l'interfaccia utente di Cloud Build.

Crea trigger (e connetti repository)

  • Vai alla pagina https://console.cloud.google.com/cloud-build/triggers
  • Fai clic su "Crea trigger".
  • Compila:
  • Nome: un nome significativo, ad esempio on-git-commit-build-php-app
  • Evento: Push al ramo
  • Fonte: "Connetti nuovo repository" testo alternativo
  • Si aprirà una finestra sulla destra: "Connetti repository"
  • Provider di origine: "Github" (primo)
  • "Continua"
  • L'autenticazione aprirà una finestra su GitHub per l'autenticazione incrociata. Segui il flusso e sii paziente. Se hai molti repository, l'operazione potrebbe richiedere un po' di tempo.
  • "Seleziona repository" Seleziona il tuo account/repository e seleziona la parte "Comprendo…".
  • Se hai ricevuto l'errore: l'app GitHub non è installata su nessuno dei tuoi repository, fai clic su "Installa Google Cloud Build" e segui le istruzioni.
  • 23e0e0f1219afea3.pngFai clic su Collega
  • bafd904ec07122d2.png
  • Bingo! Il tuo repository è ora connesso.
  • Torniamo alla parte relativa ai trigger…
  • Configurazione: Rilevamento automatico (*)
  • Avanzate: seleziona l'account di servizio "[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
  • xxxxx è l'ID progetto
  • Il service account Compute predefinito è adatto per un approccio di laboratorio, ma non utilizzarlo in produzione. (Scopri di più).
  • lascia invariato tutto il resto.
  • Fai clic sul pulsante "Crea".

(*) Questo è il modo più semplice, in quanto verifica la presenza di Dockerfile o cloudbuild.yaml. Tuttavia, cloudbuild.yaml ti dà il potere reale di decidere cosa fare in ogni passaggio.

I've got the power!

Ora, il trigger non funzionerà a meno che non concedi al service account Cloud Build (che cos'è un service account? L'indirizzo email di un "robot" che agisce per tuo conto per un'attività, in questo caso la creazione di elementi nel cloud.

Il tuo SA non riuscirà a creare ed eseguire il deployment a meno che tu non lo autorizzi a farlo. Per fortuna è facile.

  • Vai a "Cloud Build" > "Impostazioni".
  • Service account "[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
  • Seleziona queste caselle:
  • Cloud Run
  • Secret Manager
  • Service account
  • Cloud Build
  • Seleziona anche "Imposta come service account preferito".

8715acca72286a46.png

Dove si trova il file YAML di Cloud Build?

Ti consigliamo vivamente di dedicare un po' di tempo alla creazione del tuo file YAML di Cloud Build.

Tuttavia, se non hai tempo o non vuoi dedicare tempo, puoi trovare ispirazione in questa cartella delle soluzioni: .solutions

Ora puoi eseguire il push di una modifica su GitHub e osservare Cloud Build che fa la sua parte.

La configurazione di Cloud Build può essere complicata. Aspettati un po' di avanti e indietro:

97acd16980a144ab.png

Tieni presente che se utilizzi questa soluzione, c'è ancora del lavoro da fare. Ad esempio, devi impostare le variabili ENV per gli endpoint dev/prod appena creati:

3da8723e4ff80c0a.png

A tale scopo, puoi procedere in uno dei due seguenti modi:

  • Tramite la UI, impostando nuovamente le variabili di ambiente
  • Tramite l'CLI, creando lo script "perfetto" per te. Un esempio è disponibile qui: gcloud-run-deploy.sh. Devi modificare alcuni elementi, ad esempio l'endpoint e il numero di progetto. Puoi trovare il numero di progetto nella Panoramica di Cloud.

How do i commit code to github?

Insegnarti il modo migliore per eseguire il git push su GitHub non rientra nell'ambito di questo workshop. Tuttavia, se non riesci ad andare avanti e sei in Cloud Shell, puoi procedere in due modi:

  1. CLI. Aggiungi una chiave SSH localmente e aggiungi un telecomando con git@github.com:YOUR_USER/app-mod-workshop.git (anziché http)
  2. VSCode. Se utilizzi l'editor di Cloud Shell, puoi utilizzare la scheda Controllo del codice sorgente (Ctrl-Maiusc-G), fare clic su "Sincronizza modifiche" e seguire le istruzioni. Dovresti essere in grado di autenticare il tuo account GitHub su VS Code e le operazioni di pull/push da lì diventano un gioco da ragazzi.

f0d53f839c7fa3b6.png

Ricordati di git add clodubuild.yaml tra gli altri file, altrimenti non funzionerà.

[Facoltativo] Parità di sviluppo/produzione profonda e superficiale

Se hai copiato la versione del modello da qui, avrai due versioni DEV e PROD identiche. È una funzionalità interessante e in linea con la regola 10 della twelve-factor app.

Tuttavia, utilizziamo due endpoint web diversi per fare in modo che un'app punti allo stesso database. Questo è sufficiente per un workshop, ma nella vita reale è necessario dedicare un po' di tempo alla creazione di un ambiente di produzione adeguato. Ciò significa avere due database (uno per lo sviluppo e uno per la produzione) e scegliere anche dove posizionarli per il disaster recovery/l'alta affidabilità. Questo va oltre l'ambito di questo workshop, ma è un buon spunto di riflessione.

Se hai tempo per eseguire una versione "approfondita" della produzione, tieni presente tutte le risorse che devi duplicare, ad esempio:

  • Database Cloud SQL (e probabilmente istanza SQL).
  • Bucket GCS
  • Funzione Cloud Functions.
  • Potresti utilizzare Gemini 1.5 Flash come modello in fase di sviluppo (più economico, più veloce) e Gemini 1.5 Pro (più potente).

In generale, ogni volta che esegui un'operazione sull'app, pensa in modo critico: la produzione deve avere lo stesso valore o no? In caso contrario, raddoppia gli sforzi. Questo è ovviamente molto più semplice con Terraform, dove puoi inserire il tuo ambiente (-dev, -prod) come suffisso delle tue risorse.

8. Modulo 6: passa a Google Cloud Storage

a680e0f287dd2dfb.png

Spazio di archiviazione

dc3a4b8ea92aaef6.png

Al momento, l'app memorizza lo stato in un container Docker. Se la macchina si rompe, l'app esplode o semplicemente se esegui il push di una nuova revisione, verrà pianificata una nuova revisione con un nuovo spazio di archiviazione vuoto: 🙈

Come possiamo risolvere il problema? Esistono diversi approcci.

  1. Archivia le immagini nel database. È quello che ho finito per fare con la mia app PHP precedente. È la soluzione più semplice, in quanto non aggiunge complessità. Ma sicuramente aggiunge latenza e carico al tuo DB.
  2. Esegui la migrazione della tua app Cloud Run a una soluzione di archiviazione più adatta: GCE + Persistent Disk? Forse GKE + Storage? Nota: ciò che guadagni in controllo, lo perdi in agilità.
  3. Passa a GCS. Google Cloud Storage offre il miglior spazio di archiviazione per l'intero Google Cloud ed è la soluzione più idiomatica per il cloud. Tuttavia, richiede di sporcarsi le mani con le librerie PHP. Abbiamo librerie PHP 5.7 per GCS? PHP 5.7 supporta Composer (sembra che PHP 5.3.2 sia la versione più recente supportata da Composer)?
  4. Forse usare un sidecar Docker?
  5. In alternativa, utilizza i punti di montaggio dei volumi di Cloud Run di GCS. Sembra fantastico.

🤔 Migrate storage (open ended)

[Domanda aperta] In questo esercizio, vogliamo che tu trovi una soluzione per spostare le tue immagini in modo che vengano mantenute in qualche modo.

Test di accettazione

Non voglio dirti la soluzione, ma voglio che accada questo:

  1. Carichi newpic.jpg. Lo vedi nell'app.
  2. Esegui l'upgrade dell'app a una nuova versione.
  3. newpic.jpg è ancora lì, visibile.

💡 Soluzione possibile (supporti dei volumi Cloud Run di GCS)

Si tratta di una soluzione molto elegante che ci consente di ottenere caricamenti di file di stato senza toccare il codice (a parte mostrare una descrizione dell'immagine, ma è un'operazione banale e solo per soddisfazione visiva).

In questo modo dovresti essere in grado di montare una cartella da Cloud Run a GCS, quindi:

  1. Tutti i caricamenti su GCS saranno effettivamente visibili nella tua app.
  2. Tutti i caricamenti sulla tua app verranno effettivamente caricati su GCS
  3. La magia avverrà sugli oggetti caricati in GCS (capitolo 7).

Nota: Leggi le clausole di FUSE. Questo NON va bene se le prestazioni sono un problema.

Crea un bucket GCS

GCS è il servizio di archiviazione onnipresente di Google Cloud. È collaudato e viene utilizzato da ogni servizio GCP che richiede spazio di archiviazione.

Tieni presente che Cloud Shell esporta PROJECT_ID come GOOGLE_CLOUD_PROJECT:

$ export PROJECT_ID=$GOOGLE_CLOUD_PROJECT

#!/bin/bash

set -euo pipefail

# Your Cloud Run Service Name, eg php-amarcord-dev
SERVICE_NAME='php-amarcord-dev'
BUCKET="${PROJECT_ID}-public-images"
GS_BUCKET="gs://${BUCKET}"

# Create bucket
gsutil mb -l "$GCP_REGION" -p "$PROJECT_ID" "$GS_BUCKET/"

# Copy original pictures there - better if you add an image of YOURS before.
gsutil cp ./uploads/*.png "$GS_BUCKET/"

Configura Cloud Run per montare il bucket nella cartella /uploads/

Ora passiamo alla parte elegante. Creiamo un volume php_uploads e indichiamo a Cloud Run di eseguire un montaggio FUSE su MOUNT_PATH (ad esempio /var/www/html/uploads/):

#!/bin/bash

set -euo pipefail

# .. keep variables from previous script..

# Uploads folder within your docker container.
# Tweak it for your app code.
MOUNT_PATH='/var/www/html/uploads/'

# Inject a volume mount to your GCS bucket in the right folder.
gcloud --project "$PROJECT_ID" beta run services update "$SERVICE_NAME" \
    --region $GCP_REGION \
    --execution-environment gen2 \
    --add-volume=name=php_uploads,type=cloud-storage,bucket="$BUCKET"  \
    --add-volume-mount=volume=php_uploads,mount-path="$MOUNT_PATH"

Ora ripeti questo passaggio per tutti gli endpoint che vuoi indirizzare a Cloud Storage.

Puoi ottenere lo stesso risultato anche dalla UI

  1. Nella scheda "Volumi", crea un montaggio di volumi che punti al tuo bucket, di tipo "Bucket Cloud Storage", ad esempio con il nome "php_uploads".
  2. In Container > Montaggi volumi, monta il volume appena creato sul punto del volume richiesto dalla tua app. Dipende dal Dockerfile, ma potrebbe essere simile a var/www/html/uploads/ .

In entrambi i casi, se funziona, la modifica della nuova revisione di Cloud Run dovrebbe mostrare un risultato simile al seguente:

6c2bb98fc1b0e077.png

Ora testa la nuova applicazione caricando una nuova immagine nell'endpoint /upload.php.

Le immagini dovrebbero fluire senza problemi su GCS senza scrivere una sola riga di PHP:

70032b216afee2d7.png

Che cosa è successo?

È successo qualcosa di magico.

Un'applicazione precedente con un codice precedente sta ancora svolgendo il suo lavoro. Un nuovo stack modernizzato ci consente di avere tutte le immagini/foto della nostra app comodamente archiviate in un bucket Cloud stateful. Ora non ci sono più limiti:

  • Vuoi inviare un'email ogni volta che viene ricevuta un'immagine con "pericoloso" o "nudo"? Puoi farlo senza toccare il codice PHP.
  • Vuoi utilizzare un modello Gemini multimodale ogni volta che viene visualizzata un'immagine per descriverla e caricare il database con la relativa descrizione? Puoi farlo senza toccare il codice PHP. Non mi credi? Continua a leggere il capitolo 7.

Abbiamo appena sbloccato un'enorme opportunità.

9. Modulo 7: Potenzia la tua app con Google Gemini

c00425f0ad83b32c.png

Ora hai una nuova fantastica app PHP modernizzata (come una Fiat 126 del 2024) con spazio di archiviazione cloudificato.

A cosa serve

Prerequisiti

Nel capitolo precedente, una soluzione modello ci ha permesso di montare le immagini /uploads/ su GCS, separando di fatto la logica dell'app dallo spazio di archiviazione delle immagini.

Questo esercizio richiede di:

  • Aver completato con successo l'esercizio del capitolo 6 (archiviazione).
  • Avere un bucket GCS con i caricamenti delle immagini, in cui le persone caricano le immagini sulla tua app e le immagini vengono trasferite nel tuo bucket.

Configura una funzione Cloud Functions (in Python)

Ti sei mai chiesto come implementare un'applicazione basata su eventi? Ad esempio:

  • quando si verifica <evento> => invia un'email
  • quando si verifica <event> => se <condition> è true, aggiorna il database.

Un evento può essere qualsiasi cosa, da un nuovo record disponibile in BigQuery, a un nuovo oggetto modificato in una cartella in GCS o a un nuovo messaggio in attesa in una coda in Pub/Sub.

Google Cloud supporta più paradigmi per raggiungere questo obiettivo. In particolare:

In questo esercizio, approfondiremo Cloud Functions per ottenere un risultato piuttosto spettacolare. Inoltre, ti forniremo degli esercizi facoltativi.

Tieni presente che il codice campione è fornito ai sensi della licenza .solutions/

Configura una funzione Cloud Functions (🐍 Python)

Stiamo cercando di creare un GCF molto ambizioso.

  1. Quando viene creata una nuova immagine su GCS… (probabilmente perché qualcuno l'ha caricata sull'app, ma non solo)
  2. .. call Gemini to describe it and get a textual description of the image .. (would be nice to check the MIME and ensure its an image and not a PDF, MP3, or Text)
  3. .. and update the DB with this description. (potrebbe essere necessario applicare una patch al database per aggiungere una colonna description alla tabella images).

Esegui il patch del database per aggiungere description alle immagini

  1. Apri Cloud SQL Studio:

b92b07c4cba658ef.png

  1. Inserisci il nome utente e la password per il database delle immagini
  2. Inserisci questo codice SQL che aggiunge una colonna per la descrizione di un'immagine:

ALTER TABLE images ADD COLUMN description TEXT;

3691aced78a6389.png

E bingo! Prova ora a verificare se ha funzionato:

SELECT * FROM images;

Dovresti vedere la nuova colonna Descrizione:

bed69d6ad0263114.png

Scrivi la f(x) di Gemini

Nota: Questa funzione è stata creata con l'aiuto di Gemini Code Assist.

Nota: La creazione di questa funzione potrebbe comportare errori di autorizzazione IAM. Alcuni sono documentati di seguito nel paragrafo "Possibili errori".

  1. Abilita le API
  2. Vai alla pagina https://console.cloud.google.com/functions/list.
  3. Fai clic su "Crea funzione".
  4. Abilita le API dalla procedura guidata API:

d22b82658cfd4c48.png

Puoi creare la funzione Cloud Functions dall'interfaccia utente o dalla riga di comando. In questo caso utilizzeremo la riga di comando.

Un possibile codice è disponibile in .solutions/

  1. Crea una cartella per ospitare il tuo codice, ad esempio "gcf/". Accedi alla cartella.
  2. Crea un file requirements.txt:
google-cloud-storage
google-cloud-aiplatform
pymysql
  1. Crea una funzione Python. Codice campione qui: gcf/main.py.
#!/usr/bin/env python

"""Complete this"""

from google.cloud import storage
from google.cloud import aiplatform
import vertexai
from vertexai.generative_models import GenerativeModel, Part
import os
import pymysql
import pymysql.cursors

# Replace with your project ID
PROJECT_ID = "your-project-id"
GEMINI_MODEL = "gemini-1.5-pro-002"
DEFAULT_PROMPT = "Generate a caption for this image: "

def gemini_describe_image_from_gcs(gcs_url, image_prompt=DEFAULT_PROMPT):
    pass

def update_db_with_description(image_filename, caption, db_user, db_pass, db_host, db_name):
    pass

def generate_caption(event, context):
    """
    Cloud Function triggered by a GCS event.
    Args:
        event (dict): The dictionary with data specific to this type of event.
        context (google.cloud.functions.Context): The context parameter contains
                                                event metadata such as event ID
                                                and timestamp.
    """
    pass
  1. Esegui il push della funzione. Puoi utilizzare uno script simile a questo: gcf/push-to-gcf.sh.

Nota 1. Assicurati di assegnare alle variabili di ambiente i valori corretti o aggiungili in alto (GS_BUCKET=blah, ..):

Nota 2. In questo modo verrà eseguito il push di tutto il codice locale (.), quindi assicurati di inserire il codice in una cartella specifica e di utilizzare .gcloudignore come un professionista per evitare di eseguire il push di librerie di grandi dimensioni. (esempio).

#!/bin/bash

set -euo pipefail

# add your logic here, for instance:
source .env || exit 2 

echo "Pushing ☁️ f(x)☁ to 🪣 $GS_BUCKET, along with DB config.. (DB_PASS=$DB_PASS)"

gcloud --project "$PROJECT_ID" functions deploy php_amarcord_generate_caption \
    --runtime python310 \
    --region "$GCP_REGION" \
    --trigger-event google.cloud.storage.object.v1.finalized \
    --trigger-resource "$BUCKET" \
    --set-env-vars "DB_HOST=$DB_HOST,DB_NAME=$DB_NAME,DB_PASS=$DB_PASS,DB_USER=$DB_USER" \
    --source . \
    --entry-point generate_caption \
    --gen2

Nota: in questo esempio, generate_caption sarà il metodo richiamato e la funzione Cloud Functions gli passerà l'evento GCS con tutte le informazioni pertinenti (nome del bucket, nome dell'oggetto e così via). Dedica un po' di tempo al debug del dizionario Python dell'evento.

Test della funzione

Test delle unità

La funzione ha molte parti in movimento. Potresti voler testare tutti i singoli elementi.

Un esempio è disponibile in gcf/test.py.

UI di Cloud Functions

Prenditi anche un po' di tempo per esplorare la tua funzione nell'interfaccia utente. Vale la pena esplorare ogni scheda, in particolare Source (la mia preferita), Variables, Trigger e Logs. Trascorrerai molto tempo in Logs per risolvere gli errori (vedi anche i possibili errori in fondo a questa pagina). Assicurati anche di controllare Permissions.

cf3ded30d532a2c7.png

Test E2E

È il momento di testare manualmente la funzione.

  1. Vai all'app e accedi
  2. Carica un'immagine (non troppo grande, abbiamo riscontrato problemi con le immagini di grandi dimensioni)
  3. Controlla nell'interfaccia utente che l'immagine sia stata caricata.
  4. Verifica in Cloud SQL Studio che la descrizione sia stata aggiornata. Accedi ed esegui questa query: SELECT * FROM images.

43a680b12dbbdda0.png

È un sistema che funziona ottimamente. Potremmo anche voler aggiornare il frontend per mostrare la descrizione.

Aggiorna PHP per mostrare [facoltativo]

Abbiamo dimostrato che l'app funziona. Tuttavia, sarebbe utile che anche gli utenti potessero visualizzare questa descrizione.

Non è necessario essere esperti di PHP per aggiungere la descrizione a index.php. Questo codice dovrebbe funzionare (sì, anche questo l'ha scritto Gemini per me):

<?php if (!empty($image['description'])): ?>
    <p class="font-bold">Gemini Caption:</p>
    <p class="italic"><?php echo $image['description']; ?></p>
<?php endif; ?>

Posiziona questo codice all'interno di foreach come preferisci.

Nei passaggi successivi vedremo anche una versione più accattivante della UI, grazie a Gemini Code Assist. Una versione più leggibile potrebbe essere simile alla seguente:

fdc12de0c88c4464.png

Conclusioni

Hai una funzione Cloud Functions attivata sui nuovi oggetti che arrivano su GCS, in grado di annotare i contenuti dell'immagine come farebbe un essere umano e di aggiornare automaticamente il DB. Wow!

Passaggi successivi Puoi seguire lo stesso ragionamento per ottenere due ottime funzionalità.

[opzionale] Aggiungi ulteriori funzioni cloud [aperte]

Mi vengono in mente un paio di funzionalità aggiuntive.

📩 Email Trigger

Un trigger email che ti invia un'email ogni volta che qualcuno invia un'immagine.

  • Troppo spesso? Aggiungi un ulteriore vincolo: un'immagine GRANDE o un'immagine i cui contenuti di Gemini includono le parole "nudo/nudità/violento".
  • Valuta la possibilità di controllare EventArc per questo.

🚫 Modera automaticamente le foto inappropriate

Al momento, un amministratore umano contrassegna le immagini come "Inappropriate". Che ne dici di lasciare che Gemini faccia il lavoro pesante e moderi lo spazio? Aggiungi un test per segnalare i contenuti dei trigger inappropriati e aggiorna il database come abbiamo imparato nella funzione precedente. In pratica, si tratta di prendere la funzione precedente, modificare il prompt e aggiornare il database in base alla risposta.

Avvertenza. L'AI generativa ha output imprevedibili. Assicurati che l'output creativo di Gemini sia "on rails". Potresti chiedere una risposta deterministica, come un punteggio di confidenza da 0 a 1, un JSON e così via. Puoi ottenere questo risultato in molti modi, ad esempio: * Utilizzando le librerie Python pydantic, langchain e così via. * Utilizzando l'output strutturato di Gemini.

Suggerimento. Puoi avere PIÙ funzioni o un singolo prompt che impone una risposta JSON (funziona benissimo con "Output strutturato di Gemini" come evidenziato sopra), ad esempio:

Quale sarebbe il prompt per generare questo risultato?

{
    "description": "This is the picture of an arrosticino",
    "suitable": TRUE
}

Puoi aggiungere nel prompt campi aggiuntivi per ottenere insight come: c'è qualcosa di positivo? Cosa c'è di male? Riconosci il luogo? Is there some text (OCR has never been easier):

  • goods: "Sembra cibo delizioso"
  • bads: "Sembra cibo poco sano"
  • OCR: "Da consumare preferibilmente prima del 10 Novembre 2024"
  • location: "Pescara, Lungomare"

Anche se di solito è meglio avere N funzioni per N risultati, è incredibilmente gratificante crearne una che fa 10 cose. Leggi questo articolo di Riccardo per scoprire come fare.

Possibili errori (principalmente IAM/autorizzazioni)

La prima volta che ho sviluppato questa soluzione, ho riscontrato alcuni problemi relativi alle autorizzazioni IAM. Le aggiungerò qui per empatia e per dare alcune idee su come risolverle.

Errore: autorizzazioni insufficienti per il service account

  1. Tieni presente che per eseguire il deployment di una funzione GCF che ascolta un bucket GCS devi configurare le autorizzazioni appropriate per l'account di servizio che utilizzi per il job, come mostrato nella figura:

22f51012fa6b4a24.png

Potresti anche dover abilitare le API EventArc: attendi qualche minuto prima che diventino completamente disponibili.

Errore: invoker di Cloud Run mancante

  1. Un altro commento dall'interfaccia utente per l'autorizzazione di Cloud Functions è questo (ruolo Cloud Run Invoker):

be72e17294f2d3f3.png

Questo errore può essere corretto eseguendo il comando nell'immagine, che è simile a fix-permissions.sh

Questo problema è descritto qui: https://cloud.google.com/functions/docs/securing/authenticating

Errore: limite di memoria superato

La prima volta che l'ho eseguita, i miei log potrebbero aver detto: "Limite di memoria di 244 MiB superato con 270 MiB utilizzati. Valuta la possibilità di aumentare il limite di memoria, consulta https://cloud.google.com/functions/docs/configuring/memory'". Anche in questo caso, aggiungi RAM alla funzione Cloud Functions. È semplicissimo farlo nella UI. Ecco un possibile aumento:

bed69d6ad0263114.png

In alternativa, puoi anche correggere lo script di deployment di Cloud Run per aumentare la memoria/CPU. L'operazione richiede un po' più di tempo.

Errore: Pub/Sub pubblicato

La creazione di un trigger con GCF v1 ha generato questo errore:

e5c338ee35ad4c24.png

Anche in questo caso, il problema è facile da risolvere andando su IAM e assegnando al service account il ruolo "Pub/Sub Publisher".

Errore: Vertex AI non è stato utilizzato

Se ricevi questo errore:

Permission Denied: 403 Vertex AI API has not been used in project YOUR_PROJECT before or it is disabled. Abilitala visitando la pagina https://console.developers.google.com/apis/api/aiplatform.googleapis.com/overview?project=YOR_PROJECT

Devi solo abilitare le API Vertex AI. Il modo più semplice per abilitare TUTTE le API necessarie è il seguente:

  1. https://console.cloud.google.com/vertex-ai
  2. Fai clic su "Abilita tutte le API consigliate".

492f05ac377f3630.png

Errore: trigger Eventarc non trovato.

In questo caso, esegui nuovamente il deployment della funzione.

8ec4fc11833d7420.png

Errore: 400 È in corso il provisioning degli agenti di servizio

400 È in corso il provisioning degli agenti di servizio (https://cloud.google.com/vertex-ai/docs/general/access-control#service-agents). Gli agenti di servizio sono necessari per leggere il file Cloud Storage fornito. Riprova tra qualche minuto.

In questo caso, attendi un po' di tempo o chiedi a un Googler.

10. Modulo 8: Crea SLO di disponibilità

In questo capitolo cerchiamo di raggiungere questo obiettivo:

  1. Creazione di SLI
  2. Creazione di SLO in base agli SLI
  3. Creazione di avvisi basati sugli SLO

f63426182c052123.png

Questo è un argomento molto caro all'autore, poiché Riccardo lavora nell'area SRE/DevOps di Google Cloud.

(Domanda aperta) Crea SLI e SLO per questa app

A cosa serve un'app se non puoi sapere quando non funziona?

Che cos'è uno SLO?

Oh wow! Google ha inventato gli SLO. Per saperne di più, posso suggerirti:

Passaggio 1: crea SLI/SLO di disponibilità

Iniziamo con lo SLO di disponibilità, in quanto è il più semplice e probabilmente l'aspetto più importante che vuoi misurare.

Fortunatamente, Cloud Run include il supporto predefinito per gli SLO, grazie a Istio.

Una volta che l'app è su Cloud Run, è semplicissimo farlo, mi bastano 30 secondi.

  • Vai alla pagina Cloud Run.
  • Fai clic/seleziona la tua app.
  • Seleziona la scheda SLOs.
  • Fai clic su "+ Crea SLO".
  • Disponibilità, basata sulle richieste
  • Continua
  • Mese di calendario/99%.
  • fai clic su "Crea SLO".

e471c7ebdc56cdf6.png

Passaggio 2: configura gli avvisi per questo SLO

Ti suggerisco di creare due avvisi:

  1. Uno con un burn rate basso ("Slowburn") per avvisarti via email (simula un ticket con priorità bassa).
  2. Uno con un burn rate elevato ("Fastburn") per avvisarti tramite SMS (simula un ticket/pager con priorità elevata)

Vai alla SLO tab precedente.

Esegui questa operazione due volte:

314bfd6b9ef0a260.png

  • Fai clic su "Crea avviso SLO" (il pulsante 🔔 con un segno più all'interno, a destra).
  • Durata ricerca, soglia burn rate:
  • [FAST]. Primo: 60 min/10 x
  • [SLOW]. Secondo: 720 min/2 x
  • Canale di notifica: fai clic su Gestisci canali di notifica
  • Innanzitutto, "Email" -> Aggiungi nuova -> ..
  • In secondo luogo, "SMS" -> Aggiungi nuovo -> Verifica sullo smartphone.
  • Suggerimento: mi piace usare le emoji nei nomi. È divertente per le demo.
  • Al termine, fai clic sulla X grande in alto a destra.
  • Seleziona prima il telefono (veloce), poi l'email (lenta).
  • Aggiungi della documentazione di esempio, ad esempio:
  • [PHP Amarcord] Riccardo told me to type sudo reboot or to check documentation in http://example.com/playbooks/1.php but I guess he was joking.

Bingo!

Risultato finale

Possiamo considerare terminato questo esercizio una volta che hai 1 SLO funzionante + 2 avvisi per la tua disponibilità e che questi avvisi vengono inviati alla tua email e al tuo telefono.

Se vuoi, puoi aggiungere un indicatore Latenza (e ti consiglio vivamente di farlo) o anche uno più complesso. Per la latenza, scegli un valore che ritieni ragionevole. In caso di dubbi, scegli 200 ms.

11. Passaggi successivi

Hai completato TUTTO, cosa manca?

Alcuni spunti di riflessione:

Gioca con Gemini

Puoi utilizzare Gemini in due modi:

  1. Vertex AI. Il "metodo Enterprise", intrecciato con GCP, che abbiamo esplorato nel capitolo 7 (GCF+Gemini). Tutta l'autenticazione funziona magicamente e i servizi si interconnettono perfettamente.
  2. Google AI. Il "metodo consumer". Puoi ottenere una chiave API Gemini da qui e iniziare a creare piccoli script che possono essere collegati a qualsiasi workload già esistente (lavoro proprietario, altri cloud, localhost…). Basta sostituire la chiave API e il codice inizia magicamente a funzionare.

Ti invitiamo a provare a esplorare (2) con i tuoi progetti personali.

UI Lifting

Non sono molto bravo con le UI. Ma Gemini sì! Puoi semplicemente prendere una singola pagina PHP e dire qualcosa del genere:

I have a VERY old PHP application. I want to touch it as little as possible. Can you help me:

1. add some nice CSS to it, a single static include for tailwind or similar, whatever you prefer
2. Transform the image print with description into cards, which fit 4 per line in the canvas?

Here's the code:

-----------------------------------
[Paste your PHP page, for instance index.php - mind the token limit!]

Puoi ottenerlo facilmente in meno di 5 minuti, con una sola build di Cloud Build. :)

La risposta di Gemini è stata perfetta (ovvero, non ho dovuto cambiare nulla):

8a3d5fe37ec40bf8.png

Ecco il nuovo layout nell'app personale dell'autore:

81620eb90ae3229a.png

Nota: il codice viene incollato come immagine perché non vogliamo incoraggiarti a prendere il codice, ma a far sì che Gemini lo scriva per te, con i tuoi vincoli di UI/frontend creativi; fidati, in seguito dovrai apportare solo piccolissime modifiche.

Sicurezza

La protezione adeguata di questa app non è un obiettivo di questo workshop di 4 ore, in quanto aumenterebbe il tempo necessario per completarlo di 1-2 ordini di grandezza.

Tuttavia, questo argomento è molto importante. Abbiamo raccolto alcune idee in SECURITY.

12. Complimenti!

Congratulazioni 🎉🎉🎉 , hai modernizzato con successo la tua applicazione PHP legacy con Google Cloud.

24cb9a39b1841fbd.png

In sintesi, in questo codelab hai imparato:

  • Come eseguire il deployment di un database in Google Cloud SQL e come eseguire la migrazione del database esistente.
  • Come containerizzare la tua applicazione PHP con Docker e Buildpack e archiviare la relativa immagine in Google Cloud Artifact Registry
  • Come eseguire il deployment dell'app containerizzata in Cloud Run e farla funzionare con Cloud SQL
  • Come archiviare/utilizzare segretamente parametri di configurazione sensibili (come la password del DB) utilizzando Google Secret Manager
  • Come configurare la pipeline CI/CD con Google Cloud Build per creare ed eseguire automaticamente il deployment della tua app PHP a ogni push di codice nel tuo repository GitHub.
  • Come utilizzare Cloud Storage per "cloudificare" le risorse dell'app
  • Come sfruttare le tecnologie serverless per creare flussi di lavoro straordinari su Google Cloud senza toccare il codice dell'app.
  • Utilizza le funzionalità multimodali di Gemini per un caso d'uso appropriato.
  • Implementa i principi SRE in Google Cloud

Questo è un ottimo punto di partenza per il tuo percorso di modernizzazione delle applicazioni con Google Cloud.

🔁 Feedback

Se vuoi raccontarci la tua esperienza con questo workshop, compila questo modulo di feedback.

Il tuo feedback è sempre gradito, così come le PR per le parti di codice di cui sei particolarmente orgoglioso.

🙏 Grazie

L'autore desidera ringraziare Mirko Gilioli e Maurizio Ipsale di Datatonic per l'aiuto nella stesura e nel test della soluzione.