Esistono diversi modi economici per ospitare un sito Web statico generato con un generatore di siti statici come Jekyll, Hugo o Pelican:
L'intero blog è stato generato staticamente usando Jekyll. Tuttavia, non sono in grado di utilizzare nessuna delle opzioni di cui sopra perché, nel corso della vita di questo blog, ho cambiato nomi di dominio, schemi URL modificati e post rinominati e desidero mantenere vivi tutti i vecchi URL
Ho ospitato questo blog utilizzando Apache e, più recentemente, nginx su una singola macchina virtuale e le funzionalità di reindirizzamento di entrambi i software funzionano bene, ma ero pronto per ospitarlo in un posto nuovo e diverso
Un post precedente descrive come reindirizzare gli URL da un vecchio dominio a un nuovo dominio utilizzando Google App Engine e Python, ma ora avevo bisogno di un modo per pubblicare contenuti statici
**e** reindirizza gli URL dallo stesso dominio. Lo stesso requisito di reindirizzamento del dominio è il motivo per cui non posso semplicemente utilizzare la funzione di solo contenuto statico di Google App Engine (collegata nell'elenco sopra). Tuttavia, posso utilizzare Google App Engine in combinazione con una semplice applicazione Golang per servire sia contenuti statici ** che ** reindirizzamenti dello stesso dominio
## Perché Google App Engine?
Prima di immergerti nel resto del post, forse ti starai chiedendo, perché ospitare un blog su Google App Engine? Ecco i miei motivi per cui:
- Se il tuo traffico rientra nel livello gratuito di App Engine di 28 ore di istanza e 1 GB di traffico in uscita al giorno, l'hosting del blog è praticamente gratuito
- Il push degli aggiornamenti viene eseguito con un solo comando
- La registrazione e il monitoraggio sono integrati utilizzando Stackdriver
- Ridimensionamento automatico su e giù in base ai modelli di traffico
- Con pochi clic, i log web possono essere facilmente inviati a qualcosa come BigQuery per l'archiviazione a lungo termine e l'analisi ad hoc
- Certificati SSL gestiti utilizzando LetâÃÂÃÂs Encrypt
## Prerequisiti
Questo post presuppone quanto segue:
- Hai familiarità con Google Cloud Platform (GCP) e hai già creato un progetto GCP
- Hai installato Google Cloud SDK
- Hai autenticato il file
gcloudcommand sul tuo account Google
Crea un progetto GCP
Se non hai ancora creato un file
**Il progetto GCP segue questi passaggi:
- Apri un browser web e crea o accedi a un account Google
- Vai alla console GCP
- Se questo è il tuo primo progetto GCP, ti verrà chiesto di creare un progetto GCP. Ogni Account Google riceve un credito di $ 300 da utilizzare entro 12 mesi per GCP. Devi inserire una carta di credito per creare un progetto GCP, ma non verrà addebitato fino all'esaurimento del credito di $ 300 o alla scadenza di 12 mesi
- Se si tratta di un nuovo progetto GCP, dovrai abilitare l'API Compute Engine accedendo alla sezione Compute Engine della console GCP e attendere il completamento dell'inizializzazione
Installa Google Cloud SDK
Se non hai ancora installato il
**Google Cloud SDK segui le istruzioni qui
Autenticare gcloud
Dopo aver creato un progetto GCP e installato Google Cloud SDK, l'ultimo passaggio consiste nell'autenticare il file
comando gcloud al tuo account Google. Apri la tua applicazione terminale ed esegui il seguente comando:
accesso autenticazione gcloud
Una pagina web si aprirà nel tuo browser web. Seleziona il tuo account Google e autorizzalo ad accedere a GCP. Una volta completato, sarai autenticato e pronto per andare avanti
## Crea una directory
Successivamente, crea una directory da qualche parte sulla tua workstation per archiviare la tua applicazione Google App Engine:
mkdir ~/Sites/example.com/app_engine
Passa a quella directory:
cd ~/Sites/example.com/app_engine
Il resto di questo post presumerà che tu stia lavorando all'interno di questa directory
Inoltre, crea una directory all'interno del file
La directory **app_engine** denominata **static
mkdir ~/Sites/example.com/app_engine/static
Rivisiterai questa directory più tardi
## Crea app.yaml
Google App Engine in genere richiede due file:
**app.yaml** e un **file di applicazione** scritto in Python, Golang, Java o PHP - in questo caso sarà Golang. **app.yaml** fornisce la configurazione necessaria per eseguire la tua applicazione. Ci sono molti parametri diversi che possono esistere in **app.yaml Questi parametri potrebbero differire in base al linguaggio di programmazione utilizzato. Per questo post verrà utilizzato Golang e qui puoi trovare tutti i parametri Golang disponibili
Crea file
**app.yaml** con i seguenti contenuti:
runtime: go api_version: gestori go1: - url:script: _go_app secure: sempre redirect_http_response_code: 301
Notare che
**sicuro: sempre** è stato impostato. Ciò significa che l'applicazione Golang verrà sempre servita su HTTPS. Se un utente finale accede all'applicazione Web tramite HTTP, per impostazione predefinita verrà reindirizzato 302 alla versione HTTPS. Questo è il motivo per cui è stato impostato anche **redirect_http_response_code: 301**. Voglio sempre che l'applicazione web venga servita su HTTPS e non voglio che i motori di ricerca interpretino il reindirizzamento da HTTP a HTTPS come un reindirizzamento temporaneo; è un reindirizzamento permanente
Se disponi di asset statici, e probabilmente li hai, è consigliabile informare App Engine di questo e lasciare che serva tali asset dall'object storage invece che dalla tua applicazione. Fare questo è facile e viene fatto anche attraverso il
**app.yaml**
Ad esempio, se disponi di un file favicon, una directory CSS, una directory Javascript e una directory delle immagini, utilizza quanto segue
File **app.yaml**:
runtime: go api_version: gestori go1: - url: /favicon.png$ static_files: static/favicon.png upload: static/favicon.png - url: /css static_dir: static/css - url: /js static_dir: static/js - url: /images static_dir: static/images - url:script: _go_app secure: sempre redirect_http_response_code: 301
## Crea main.go
Successivamente, è necessario il file dell'applicazione Golang
Affinché il codice seguente soddisfi le tue esigenze, crea file
**main.go copia e incolla il codice sottostante e apporta le seguenti modifiche:
- Nel
domainvariable, modifica il valore in modo che corrisponda al tuo nome di dominio con il protocollo HTTP corretto
- Nel
urlsmap, sostituisci tutte le coppie chiave-valore in modo che corrispondano ai reindirizzamenti di cui hai bisogno. Sostituisci ogni chiave con solo la parte del percorso ( /example-post-1.htmlinvece di httpsexample.com/example-post-1.html) del vecchio URL del dominio corrente che desideri mantenersi in vita. Quindi sostituisci ogni valore con la parte del percorso del nuovo URL del dominio corrente a cui desideri reindirizzare
Tutti i reindirizzamenti saranno reindirizzamenti 301. Questo può essere modificato cambiando
**301** nel codice seguente a un diverso codice di stato di reindirizzamento HTTP come **302**
package main import ( "net/http""os""strings") func init() { http.HandleFunc handler) } func handler(w http.ResponseWriter, r *http.Request) { // True (ok) se richiesta path è nella mappa degli URL if value, ok := urls[r.URL.Path]; ok { value = dominio + valore http.Redirect(w, r, value, 301) } else { path := "static/"+ r.URL.Path // Restituisce 403 se la richiesta HTTP è a una directory che esiste e funziona non contenere un file index.html se f, err := os.Stat(percorso); err == nil&& f.IsDir() { index := strings.TrimSuffix(path,+ "/index.html"if _, err := os.Open(index); err != nil { w.WriteHeader (403) w.Writebytehtml>
403 Proibito
403 Forbidden
return } } // Return custom 404 page if HTTP request is to a non-existent file if _, err := os.Stat(path); os.IsNotExist(err) { w.WriteHeader(404) http.ServeFile(w, r, "static/404.html") return // Withoutreturn, a "404 page not found" string will be displayed at the bottom of your custom 404 page } http.ServeFile(w, r, path) return } } var domain string = "httpsexample.com" var urls = map[string]string{ "/example-post-1.html": "/post/example-post-1.html", "/example-post-2.html": "/post/example-post-2.html", "/example-post-3.html": "/post/example-post-3.html", }
## Generate the Static Content
With
**app.yaml** and **main.go** saved, the last piece is to generate your static content and store it in the **static** directory you created earlier
How you do this entirely depends on what static site generator you are using
If you are using Jekyll, you can configure the
**destination** parameter in JekyllâÃÂÃÂs _ **config.yml** file to save your static content in any directory on your workstation. So, you could set the **destination** parameter to Sites/example.com/app_engine/static and, every time you run
jekyll build, the static content will be saved in that directory
## Deploy to App Engine
With
**app.yaml **main.go and your static content generated, you are ready to deploy your Google App Engine application
Assuming
gcloud is already pointed at the Google Cloud Project you want to deploy to, verify with
gcloud config list project, run the following command:
gcloud app deploy
The command will output the appspot URL your application will be deployed to and ask if you want to continue. Typically, the appspot URL is
**httpsyour-project-id.appspot.com This is also a useful self-check to make sure you are not deploying your application to the wrong Google Cloud Project. If everything looks okay, type **Y** and **Enter** to deploy your application. Depending on how large your static content is, your application should be deployed within about one minute
## Setup DNS
At this point, your application is deployed under URL
**httpsyour-project-id.appspot.com Unless your website uses that as its domain name, you will probably want to setup a custom domain that uses your actual current domain name
The App Engine section of the Google Cloud Console can be used to do this. Go here and follow the instructions to configure your custom domain
Once that is complete and DNS has had time to propagate, you should be able to navigate in your web browser to one of your current domainâÃÂÃÂs old URLs, for example
**httpsexample.com/example-post-1.html and have it redirect to your current domainâÃÂÃÂs new URLs, for example **httpsexample.com/post/example-post-1.html**
## Pushing Updates
To push updates, make the necessary changes in your static siteâÃÂÃÂs source directory, regenerate the static content, and redeploy to Google App Engine by changing into the
Sites/example.com/app_engine** directory and running
gcloud app deploy
## References
- A Surprising Feature of Golang that Colored Me Impressed
- How to check if a map contains a key in go?
- Disable directory listing with http.FileServer
- 3 Ways to Disable http.FileServer Directory Listings
- Handling HTTP Request Errors in GO
- HTTP and Error management in Go
- please add ability to set custom 404 notFoundHandler for http.FileServer