Es gibt mehrere kostengünstige Möglichkeiten, eine statische Website zu hosten, die mit einem Static-Site-Generator wie Jekyll, Hugo oder Pelican erstellt wurde:
Dieser gesamte Blog wird statisch mit Jekyll generiert. Ich kann jedoch keine der oben genannten Optionen verwenden, da ich während der Lebensdauer dieses Blogs Domainnamen geändert, URL-Schemata geändert und Beiträge umbenannt habe, und ich möchte dies tun Halten Sie alle alten URLs am Leben

Ich habe diesen Blog mit Apache und in jüngerer Zeit mit nginx auf einer einzigen virtuellen Maschine gehostet, und die Umleitungsfunktionen beider Softwareteile funktionieren einwandfrei, aber ich war bereit, ihn an einem neuen und anderen Ort zu hosten

Ein früherer Beitrag beschreibt, wie ich URLs von einer alten Domain zu einer neuen Domain mit Google App Engine und Python umleite, aber jetzt brauchte ich eine Möglichkeit, statische Inhalte bereitzustellen
**und** leiten URLs von derselben Domain weiter. Dieselbe Domain-Umleitungsanforderung ist der Grund, warum ich nicht einfach die Funktion "Nur statische Inhalte"von Google App Engine verwenden kann (in der obigen Liste verlinkt). Allerdings kann ich Google App Engine in Kombination mit einer einfachen Golang-Anwendung verwenden, um sowohl statische Inhalte **als auch** Umleitungen auf dieselbe Domain bereitzustellen

## Warum Google App Engine?
Bevor Sie sich mit dem Rest des Beitrags befassen, fragen Sie sich vielleicht, warum Sie einen Blog auf Google App Engine hosten sollten? Hier sind meine Gründe dafür:
- Wenn Ihr Datenverkehr in das kostenlose Kontingent von App Engine mit 28 Instanzstunden und 1 GB ausgehendem Datenverkehr pro Tag passt, ist das Hosten des Blogs praktisch kostenlos
- Das Pushen von Updates erfolgt mit einem Befehl
- Protokollierung und Überwachung sind mit Stackdriver integriert
- Automatisches Hoch- und Runterskalieren basierend auf Verkehrsmustern
- Mit wenigen Klicks können Webprotokolle zur Langzeitspeicherung und Ad-hoc-Analyse einfach an etwas wie BigQuery gepusht werden
- Verwaltete SSL-Zertifikate mit LetâÃÂÃÂs Encrypt
## Voraussetzungen
Dieser Beitrag geht von Folgendem aus:
- Sie kennen sich mit der Google Cloud Platform (GCP) aus und haben bereits ein GCP-Projekt erstellt
- Sie haben das Google Cloud SDK installiert
- Sie haben die authentifiziert
gcloudcommand für Ihr Google-Konto
 Erstellen Sie ein GCP-Projekt
Falls Sie noch keine erstellt haben
**GCP-Projekt befolgen Sie diese Schritte:
- Öffnen Sie einen Webbrowser und erstellen Sie ein Google-Konto oder melden Sie sich bei einem an
- Navigieren Sie zur GCP-Konsole
– Wenn dies Ihr erstes GCP-Projekt ist, werden Sie aufgefordert, ein GCP-Projekt zu erstellen. Jedes Google-Konto erhält ein Guthaben von 300 $, das innerhalb von 12 Monaten für die GCP verwendet werden kann. Sie müssen eine Kreditkarte eingeben, um ein GCP-Projekt zu erstellen, diese wird jedoch erst belastet, wenn das Guthaben von 300 $ aufgebraucht ist oder 12 Monate abgelaufen sind

– Wenn es sich um ein neues GCP-Projekt handelt, müssen Sie die Compute Engine-API aktivieren, indem Sie zum Abschnitt „Compute Engine“ der GCP Console navigieren und warten, bis die Initialisierung abgeschlossen ist
 Installieren Sie das Google Cloud-SDK
Falls Sie die noch nicht installiert haben
**Google Cloud SDK befolgen Sie die Anweisungen hier

 Authentifizieren Sie gcloud
Nachdem Sie ein GCP-Projekt erstellt und das Google Cloud SDK installiert haben, besteht der letzte Schritt darin, das zu authentifizieren
gcloud-Befehl an Ihr Google-Konto. Öffnen Sie Ihre Terminalanwendung und führen Sie den folgenden Befehl aus:
gcloud-Authentifizierungsanmeldung
Eine Webseite wird in Ihrem Webbrowser geöffnet. Wählen Sie Ihr Google-Konto aus und erteilen Sie ihm die Berechtigung zum Zugriff auf die GCP. Sobald Sie fertig sind, werden Sie authentifiziert und können fortfahren

## Erstellen Sie ein Verzeichnis
Erstellen Sie als Nächstes irgendwo auf Ihrer Workstation ein Verzeichnis, um Ihre Google App Engine-Anwendung zu speichern:
mkdir ~/Sites/example.com/app_engine
Wechseln Sie in dieses Verzeichnis:
cd ~/Sites/example.com/app_engine
Der Rest dieses Beitrags geht davon aus, dass Sie innerhalb dieses Verzeichnisses arbeiten

Erstellen Sie außerdem ein Verzeichnis innerhalb der
**app_engine** Verzeichnis mit dem Namen **static
mkdir ~/Sites/example.com/app_engine/static
Sie werden dieses Verzeichnis später erneut besuchen

## app.yaml erstellen
Google App Engine erfordert normalerweise zwei Dateien:
**app.yaml** und eine **Anwendungsdatei**, die in Python, Golang, Java oder PHP geschrieben ist – in diesem Fall wird es Golang sein. **app.yaml** stellt die notwendige Konfiguration bereit, um Ihre Anwendung auszuführen. Es gibt viele verschiedene Parameter, die in **app.yaml vorhanden sein können. Diese Parameter können sich je nach verwendeter Programmiersprache unterscheiden. Für diesen Beitrag wird Golang verwendet, und Sie finden alle verfügbaren Golang-Parameter hier

Erstelle Datei
**app.yaml** mit folgendem Inhalt:
Laufzeit: go api_version: go1 handlers: - url:script: _go_app secure: always forward_http_response_code: 301
Beachte das
**sicher: immer** wurde eingestellt. Das bedeutet, dass die Golang-Anwendung immer über HTTPS bereitgestellt wird. Wenn ein Endbenutzer über HTTP zur Webanwendung navigiert, wird er standardmäßig per 302 auf die HTTPS-Version umgeleitet. Deshalb wurde auch **redirect_http_response_code: 301** gesetzt. Ich möchte immer, dass die Webanwendung über HTTPS bereitgestellt wird, und ich möchte nicht, dass Suchmaschinen die Umleitung von HTTP zu HTTPS als vorübergehende Umleitung interpretieren. es ist eine permanente Weiterleitung
Wenn Sie über statische Assets verfügen, was wahrscheinlich der Fall ist, empfiehlt es sich, App Engine darüber zu informieren und diese Assets aus dem Objektspeicher statt aus Ihrer Anwendung bereitzustellen. Dies ist einfach und erfolgt auch über die
**app.yaml**-Datei

Wenn Sie beispielsweise eine Favicon-Datei, ein CSS-Verzeichnis, ein Javascript-Verzeichnis und ein Bildverzeichnis haben, verwenden Sie Folgendes
**app.yaml**-Datei:
Laufzeit: go api_version: go1 handlers: - 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: always forward_http_response_code: 301
## main.go erstellen
Als nächstes benötigen Sie die Golang-Anwendungsdatei

Damit der folgende Code Ihren Anforderungen entspricht, erstellen Sie file
**main.go Kopieren Sie den folgenden Code, fügen Sie ihn ein und nehmen Sie die folgenden Änderungen vor:
- Im
domainvariable, ändern Sie den Wert so, dass er Ihrem Domainnamen mit dem richtigen HTTP-Protokoll entspricht

- Im
urlsmap, ersetzen Sie alle Schlüssel-Wert-Paare, um mit den Umleitungen übereinzustimmen, die Sie an Ort und Stelle benötigen. Ersetzen Sie jeden Schlüssel nur durch den Pfadteil ( /example-post-1.htmlanstelle von httpsexample.com/example-post-1.html) der alten URL der aktuellen Domain, die Sie verwenden möchten bleib am Leben. Ersetzen Sie dann jeden Wert durch den Pfadteil der neuen URL der aktuellen Domain, auf die Sie umleiten möchten

Alle Weiterleitungen sind 301-Weiterleitungen. Dies kann durch Ändern geändert werden
**301** im Code unten zu einem anderen HTTP-Umleitungsstatuscode wie **302**


Paket Hauptimport ( "net/http""os""strings") func init() { http.HandleFunc handler) } func handler(w http.ResponseWriter, r *http.Request) { // True (ok) falls Anfrage Pfad ist in der URL-Zuordnung if value, ok := urls[r.URL.Path]; ok { value = domain + value http.Redirect(w, r, value, 301) } else { path := "static/"+ r.URL.Path // Gibt 403 zurück, wenn die HTTP-Anforderung an ein Verzeichnis geht, das existiert und existiert enthält keine index.html-Datei if f, err := os.Stat(path); 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