Archiviazione e pubblicazione di file statici

Spesso le applicazioni devono pubblicare file statici come JavaScript, immagini e CSS oltre a gestire le richieste dinamiche. Nell'ambiente standard, le app possono gestire file statici provenienti da un'opzione di Google Cloud come Cloud Storage, pubblicarli direttamente o utilizzare una rete CDN (Content Delivery Network) di terze parti.

L'hosting del tuo sito statico su Google Cloud può costare meno di utilizzare un provider di hosting tradizionale, poiché Google Cloud offre un livello gratuito.

Gestione dei file da Cloud Storage

Cloud Storage può ospitare asset statici per le app web dinamiche. I vantaggi dell'utilizzo di Cloud Storage invece di quelli forniti direttamente dall'app includono:

Cloud Storage funziona essenzialmente come una rete di distribuzione dei contenuti. Non è richiesta alcuna configurazione speciale perché, per impostazione predefinita, nella cache di Cloud Storage globale viene memorizzato nella cache qualsiasi oggetto leggibile al pubblico.
Il carico dell'app verrà ridotto grazie all'offload della pubblicazione di asset statici in Cloud Storage. A seconda del numero di asset statici di cui disponi e della frequenza di accesso, il costo di esecuzione dell'app può ridursi in modo significativo.
L'utilizzo della larghezza di banda per l'accesso ai contenuti può spesso essere inferiore con Cloud Storage.

Puoi caricare i tuoi asset in Cloud Storage utilizzando lo strumento a riga di comando gsutil o l'API Cloud Storage.

La libreria client di Google Cloud fornisce un client Java 11/17 idiomatico a Cloud Storage per archiviare e recuperare i dati con Cloud Storage in un'app di App Engine.

Esempio di pubblicazione da un bucket Cloud Storage

Questo semplice esempio crea un bucket di Cloud Storage e carica asset statici utilizzando l'interfaccia a riga di comando di Google Cloud:

Crea un bucket. È comune, ma non obbligatorio, assegnare un nome al bucket in base all'ID progetto. Il nome del bucket deve essere univoco a livello globale.
```
gsutil mb gs://<your-bucket-name>
```
Imposta l'ACL per concedere l'accesso in lettura agli elementi nel bucket.
```
gsutil defacl set public-read gs://<your-bucket-name>
```
Carica elementi nel bucket. Il comando rsync è in genere il modo più rapido e semplice per caricare e aggiornare gli asset. Potresti anche usare cp.
```
gsutil -m rsync -r ./static gs://<your-bucket-name>/static
```

Ora puoi accedere alle risorse statiche tramite https://storage.googleapis.com/<your-bucket-name>/static/....

Per maggiori dettagli su come utilizzare Cloud Storage per pubblicare asset statici, incluse le modalità di pubblicazione da un nome di dominio personalizzato, consulta la sezione Come ospitare un sito web statico.

Gestione di file da altri servizi Google Cloud

Hai anche la possibilità di utilizzare Cloud CDN o altri servizi di archiviazione di Google Cloud.

Pubblicazione di file direttamente dalla tua app

Per pubblicare file statici per Java 11/17 nell'ambiente standard, definisci i gestori nel file app.yaml utilizzando gli elementi static_dir o static_files.

I contenuti dei file statici o delle directory statiche non sono interessati dalle impostazioni di scalabilità nel file app.yaml. Le richieste ai file statici o alle directory statiche vengono gestite direttamente dall'infrastruttura App Engine e non raggiungono il runtime del linguaggio dell'applicazione.

Configurazione dei gestori dei file statici

Per configurare l'app in modo che pubblichi la directory ./public dall'URL /static, definisci un gestore nel file app.yaml.

Di seguito viene spiegato come pubblicare i file statici della directory ./public di un'app di esempio. Il modello di questa pagina index.html dell'app indica al browser di caricare il file main.css, ad esempio:

<link type="text/css" rel="stylesheet" href="/static/css/main.css">

La directory ./public è definita nell'elemento static_dir del file app.yaml del progetto:

handlers:
  - url: /favicon\.ico
    static_files: favicon.ico
    upload: favicon\.ico

  - url: /static
    static_dir: public

  - url: /.*
    secure: always
    redirect_http_response_code: 301
    script: auto

La sezione handlers nell'esempio precedente gestisce tre pattern URL:

Il gestore /favicon.ico mappa una richiesta specifica per /favicon.ico a un file denominato favicon.ico nella directory principale dell'app.
Il gestore /static mappa le richieste di URL che iniziano con /static. Quando App Engine riceve una richiesta di un URL che inizia con /static, mappa il resto del percorso dei file nella directory ./public. Se nella directory viene trovato un file appropriato, i contenuti del file vengono restituiti al client.
Il gestore /.* corrisponde a tutti gli altri URL e li indirizza alla tua app.

I pattern di percorsi degli URL vengono testati nell'ordine in cui appaiono in app.yaml, pertanto devono essere definiti prima del pattern /.*. Per ulteriori informazioni, consulta la pagina di riferimento app.yaml.

Esempio di pubblicazione di file statici in un'app Spring Boot

Ad esempio, per pubblicare tutti i file statici contenuti nella directory BOOT-INF/classes/static di un'app Spring Boot, completa i seguenti passaggi prima di eseguire il deployment dell'app:

Decomprimi il file JAR che contiene tutte le classi della tua app (noto anche come jar grasso).

Aggiungi il seguente campo entrypoint al file di configurazione app.yaml:

 entrypoint: java -noverify BOOT-INF/resources/:BOOT-INF/classes/:BOOT-INF/lib/* com.mycompany.myapp.YOUAPPCLASSNAME

Aggiungi i seguenti gestori al file app.yaml per configurare le risorse statiche (ciò è sempre necessario quando utilizzi un jar grasso non pacchettizzato):

  handlers:
  - url: (/.*)
    static_files: BOOT-INF/classes/static\1
    upload: BOOT-INF/classes/static/.*\.(gif|png|jpg|svg|ico|css|js|html)$
    require_matching_file: True
    login: optional
    secure: optional

quindi esegui il deployment dell'app.

Pubblicazione da una rete CDN (Content Delivery Network) di terze parti

Puoi utilizzare qualsiasi CDN esterna di terze parti per pubblicare file statici e richieste dinamiche di memorizzazione nella cache, ma la tua app potrebbe aumentare i tempi di latenza e i costi.

Per migliorare le prestazioni, devi utilizzare una rete CDN di terze parti che supporti CDN Interconnect.