Există mai multe modalități ieftine de a găzdui un site web static generat cu un generator de site-uri static precum Jekyll, Hugo sau Pelican:
Întregul blog este generat static folosind Jekyll. Cu toate acestea, nu pot folosi niciuna dintre opțiunile de mai sus, deoarece, de-a lungul vieții acestui blog, am schimbat numele de domenii, am schimbat schemele de adrese URL și am redenumit postări și vreau să păstrați vii toate vechile URL-uri

Am găzduit acest blog folosind Apache și, mai recent, nginx pe o singură mașină virtuală, iar caracteristicile de redirecționare ale fiecărei piese de software funcționează bine, dar eram gata să-l găzduiesc într-un loc nou și diferit.

O postare anterioară descrie cum redirecționez adresele URL de la un domeniu vechi la un domeniu nou folosind Google App Engine și Python, dar acum aveam nevoie de o modalitate de a difuza conținut static
**și** adrese URL de redirecționare din același domeniu. Aceeași cerință de redirecționare a domeniului este motivul pentru care nu pot folosi pur și simplu funcția Google App Engine numai pentru conținut static (legată în lista de mai sus). Cu toate acestea, pot folosi Google App Engine în combinație cu o aplicație simplă Golang pentru a difuza atât conținut static **și** redirecționări pe același domeniu

## De ce Google App Engine?
Înainte de a vă scufunda în restul postării, poate vă întrebați, de ce găzduiți un blog pe Google App Engine? Iată motivele mele pentru care:
- Dacă traficul dvs. se încadrează în nivelul gratuit al App Engine de 28 de ore de instanță și 1 GB de trafic de ieșire pe zi, găzduirea blogului este practic gratuită
- Impingerea actualizărilor se face cu o singură comandă
- Înregistrarea și monitorizarea sunt integrate folosind Stackdriver
- Scalare automată în sus și în jos pe baza modelelor de trafic
- Cu câteva clicuri, jurnalele web pot fi transferate cu ușurință în ceva precum BigQuery pentru stocare pe termen lung și analize ad-hoc
- Certificate SSL gestionate folosind LetâÃÂÃÂs Encrypt
## Cerințe preliminare
Această postare presupune următoarele:
- Sunteți familiarizat cu Google Cloud Platform (GCP) și ați creat deja un proiect GCP
- Ați instalat Google Cloud SDK
- Ai autentificat
gcloudcommand împotriva Contului dvs. Google
 Creați un proiect GCP
Dacă nu ați creat încă un
**Proiectul GCP urmați acești pași:
- Deschideți un browser web și creați sau conectați-vă la un Cont Google
- Navigați la Consola GCP
- Dacă acesta este primul dvs. proiect GCP, vi se va solicita să creați un proiect GCP. Fiecare Cont Google primește un credit de 300 USD pentru a fi utilizat în termen de 12 luni pentru GCP. Vi se cere să introduceți un card de credit pentru a crea un proiect GCP, dar acesta nu va fi debitat până când creditul de 300 USD nu este consumat sau până când expiră 12 luni

- Dacă acesta este un proiect GCP nou, va trebui să activați API-ul Compute Engine navigând la secțiunea Compute Engine din Consola GCP și așteptați finalizarea inițializării
 Instalați SDK-ul Google Cloud
Dacă nu ați instalat încă
**Google Cloud SDK urmați instrucțiunile de aici

 Autentificați gcloud
După ce ați creat un proiect GCP și ați instalat SDK-ul Google Cloud, ultimul pas este autentificarea
comanda gcloud în Contul dvs. Google. Deschideți aplicația de terminal și rulați următoarea comandă:
autentificare gcloud auth
Se va deschide o pagină web în browserul dvs. web. Selectați Contul dvs. Google și acordați-i permisiunea de a accesa GCP. Odată finalizat, veți fi autentificat și gata să mergeți mai departe

## Creați un director
Apoi, creați un director undeva pe stația de lucru pentru a stoca aplicația Google App Engine:
mkdir ~/Sites/example.com/app_engine
Schimbați în acel director:
cd ~/Sites/example.com/app_engine
Restul acestei postări va presupune că lucrați în acest director

În plus, creați un director în interiorul
Directorul **app_engine** numit **static
mkdir ~/Sites/example.com/app_engine/static
Veți revedea acest director mai târziu

## Creați app.yaml
Google App Engine necesită de obicei două fișiere:
**app.yaml** și un **fișier de aplicație** scris în Python, Golang, Java sau PHP - în acest caz, acesta va fi Golang. **app.yaml** oferă configurația necesară pentru a rula aplicația dvs. Există o mulțime de parametri diferiți care pot exista în **app.yaml Acești parametri pot diferi în funcție de limbajul de programare utilizat. Pentru această postare, va fi folosit Golang și puteți găsi toți parametrii Golang disponibili aici

Creați fișier
**app.yaml** cu următorul conținut:
runtime: go api_version: go1 handlere: - url:script: _go_app secure: întotdeauna redirect_http_response_code: 301
Observa asta
**secure: always** a fost setat. Aceasta înseamnă că aplicația Golang va fi întotdeauna servită prin HTTPS. Dacă un utilizator final navighează la aplicația web prin HTTP, acesta va fi 302 redirecționat implicit la versiunea HTTPS. Acesta este motivul pentru care a fost setat și **redirect_http_response_code: 301**. Îmi doresc întotdeauna ca aplicația web să fie servită prin HTTPS și nu vreau ca motoarele de căutare să interpreteze redirecționarea de la HTTP la HTTPS ca o redirecționare temporară; este o redirecționare permanentă
Dacă aveți active statice, și probabil că aveți, este cea mai bună practică să informați App Engine despre acest lucru și să-l lăsați să servească acele active din stocarea obiectelor și nu din aplicația dvs. A face acest lucru este ușor și se face și prin intermediul
**app.yaml** fișier

De exemplu, dacă aveți un fișier favicon, un director CSS, un director Javascript și un director de imagini, utilizați următoarele
fișier **app.yaml**:
runtime: go api_version: go1 handlers: - url: /favicon.png$ static_files: static/favicon.png încărcare: 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: întotdeauna redirect_http_response_code: 301
## Creați main.go
Apoi, aveți nevoie de fișierul aplicației Golang

Pentru ca următorul cod să răspundă nevoilor dvs., creați fișierul
**main.go copiați și lipiți codul de mai jos și faceți următoarele modificări:
- În
domainvariable, modificați valoarea pentru a se potrivi cu numele domeniului dvs. cu protocolul HTTP corect

- În
urlsmap, înlocuiți toate perechile valori-cheie pentru a se potrivi cu redirecționările de care aveți nevoie. Înlocuiți fiecare cheie cu doar porțiunea de cale ( /example-post-1.htmlîn loc de httpsexample.com/example-post-1.html) a vechii adrese URL a domeniului curent pe care doriți să o accesați ține în viață. Apoi înlocuiți fiecare valoare cu porțiunea de cale a noului URL al domeniului curent către care doriți să redirecționați

Toate redirecționările vor fi 301 redirecționări. Acest lucru poate fi modificat prin schimbare
**301** în codul de mai jos la un alt cod de stare de redirecționare HTTP, cum ar fi **302**


importul principal al pachetului ( "net/http""os""șiruri") func init() { http.HandleFunc handler) } func handler (w http.ResponseWriter, r *http.Request) { // True (ok) dacă cerere calea este în harta URL dacă valoare, ok := urls[r.URL.Path]; ok { valoare = domeniu + valoare http.Redirect(w, r, valoare, 301) } else { cale := "static/"+ r.URL.Path // Returnează 403 dacă cererea HTTP este către un director care există și nu nu contine un fisier index.html daca f, err := os.Stat(cale); err == nil&& f.IsDir() { index := strings.TrimSuffix(path,+ "/index.html"if _, err := os.Open(index); err != nil { w.WriteHeader (403) w.Writebytehtml>
              
              
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