Il existe plusieurs façons peu coûteuses d'héberger un site Web statique généré avec un générateur de site statique comme Jekyll, Hugo ou Pelican :
L'intégralité de ce blog est généré statiquement à l'aide de Jekyll. Cependant, je ne peux utiliser aucune des options ci-dessus, car, au cours de la vie de ce blog, j'ai changé les noms de domaine, changé les schémas d'URL et renommé les messages, et je veux garder en vie toutes les anciennes URL

J'ai hébergé ce blog en utilisant Apache et, plus récemment, nginx sur une seule machine virtuelle, et les fonctionnalités de redirection de l'un ou l'autre logiciel fonctionnent très bien, mais j'étais prêt à l'héberger dans un endroit nouveau et différent.

Un article précédent décrit comment je redirige les URL d'un ancien domaine vers un nouveau domaine à l'aide de Google App Engine et de Python, mais j'avais maintenant besoin d'un moyen de diffuser du contenu statique
**et** redirigent les URL du même domaine. Cette même exigence de redirection de domaine est la raison pour laquelle je ne peux pas simplement utiliser la fonctionnalité de contenu statique uniquement de Google App Engine (liée dans la liste ci-dessus). Cependant, je peux utiliser Google App Engine en combinaison avec une simple application Golang pour diffuser à la fois du contenu statique ** et ** des redirections du même domaine

## Pourquoi Google App Engine ?
Avant de plonger dans le reste de l'article, vous vous demandez peut-être pourquoi héberger un blog sur Google App Engine ? Voici mes raisons :
- Si votre trafic correspond au niveau gratuit d'App Engineer de 28 heures d'instance et 1 Go de trafic de sortie par jour, l'hébergement du blog est pratiquement gratuit.
- Pousser les mises à jour se fait avec une seule commande
- La journalisation et la surveillance sont intégrées à l'aide de Stackdriver
- Mise à l'échelle automatique vers le haut et vers le bas en fonction des modèles de trafic
- En quelques clics, les journaux Web peuvent facilement être poussés vers quelque chose comme BigQuery pour un stockage à long terme et une analyse ad hoc
- Certificats SSL gérés à l'aide de LetâÃÂÃÂs Encrypt
## Conditions préalables
Ce poste suppose ce qui suit :
- Vous connaissez Google Cloud Platform (GCP) et avez déjà créé un projet GCP
- Vous avez installé le SDK Google Cloud
- Vous avez authentifié le
gcloudcommand sur votre compte Google
 Créer un projet GCP
Si vous n'avez pas encore créé de
** Le projet GCP suit ces étapes :
- Ouvrez un navigateur Web et créez ou connectez-vous à un compte Google
- Accédez à la console GCP
- S'il s'agit de votre premier projet GCP, vous serez invité à créer un projet GCP. Chaque compte Google bénéficie d'un crédit de 300 $ à utiliser dans les 12 mois vers GCP. Vous devez saisir une carte de crédit pour créer un projet GCP, mais celle-ci ne sera pas débitée tant que le crédit de 300 $ n'aura pas été consommé ou que les 12 mois n'auront pas expiré.

- S'il s'agit d'un nouveau projet GCP, vous devrez activer l'API Compute Engine en accédant à la section Compute Engine de la console GCP et attendre la fin de l'initialisation.
 Installer le SDK Google Cloud
Si vous n'avez pas encore installé le
**Google Cloud SDK suivez les instructions ici

 Authentifier gcloud
Une fois que vous avez créé un projet GCP et installé le SDK Google Cloud, la dernière étape consiste à authentifier le
commande gcloud à votre compte Google. Ouvrez votre application de terminal et exécutez la commande suivante :
connexion d'authentification gcloud
Une page Web s'ouvrira dans votre navigateur Web. Sélectionnez votre compte Google et autorisez-le à accéder à GCP. Une fois terminé, vous serez authentifié et prêt à aller de l'avant

## Créer un répertoire
Ensuite, créez un répertoire quelque part sur votre poste de travail pour stocker votre application Google App Engine :
mkdir ~/Sites/example.com/app_engine
Allez dans ce répertoire :
cd ~/Sites/example.com/app_engine
Le reste de ce post supposera que vous travaillez à l'intérieur de ce répertoire

De plus, créez un répertoire à l'intérieur du
Répertoire **app_engine** appelé **statique
mkdir ~/Sites/example.com/app_engine/static
Vous revisiterez ce répertoire plus tard

## Créer app.yaml
Google App Engine nécessite généralement deux fichiers :
**app.yaml** et un **fichier d'application** écrit en Python, Golang, Java ou PHP - dans ce cas, ce sera Golang. **app.yaml** fournit la configuration nécessaire pour exécuter votre application. Il existe de nombreux paramètres différents qui peuvent exister dans **app.yaml Ces paramètres peuvent différer en fonction du langage de programmation utilisé. Pour ce post, Golang sera utilisé, et vous pouvez trouver tous les paramètres Golang disponibles ici

Créer un fichier
**app.yaml** avec le contenu suivant :
runtime : go api_version : go1 handlers : - url:script : _go_app secure : always redirect_http_response_code : 301
Remarquerez que
**sécurisé : toujours** a été défini. Cela signifie que l'application Golang sera toujours servie via HTTPS. Si un utilisateur final accède à l'application Web via HTTP, il sera par défaut redirigé 302 vers la version HTTPS. C'est pourquoi **redirect_http_response_code: 301** a également été défini. Je veux toujours que l'application Web soit servie sur HTTPS, et je ne veux pas que les moteurs de recherche interprètent la redirection de HTTP vers HTTPS comme une redirection temporaire ; c'est une redirection permanente
Si vous avez des éléments statiques, et c'est probablement le cas, il est recommandé d'en informer App Engine et de le laisser diffuser ces éléments depuis le stockage d'objets plutôt que depuis votre application. Cela est facile et se fait également à travers le
fichier **app.yaml**

Par exemple, si vous avez un fichier favicon, un répertoire CSS, un répertoire Javascript et un répertoire d'images, utilisez ce qui suit
Fichier **app.yaml** :
runtime : 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 : statique/images - url : script : _go_app secure : toujours redirect_http_response_code : 301
## Créer main.go
Ensuite, vous avez besoin du fichier d'application Golang

Pour que le code suivant réponde à vos besoins, créez un fichier
**main.go copiez et collez le code ci-dessous et apportez les modifications suivantes :
- Dans le
domainvariable, modifiez la valeur pour qu'elle corresponde à votre nom de domaine avec le protocole HTTP correct

- Dans le
urlsmap, remplacez toutes les paires clé-valeur pour faire correspondre les redirections dont vous avez besoin en place. Remplacez chaque clé par uniquement la partie chemin ( /example-post-1.html au lieu de httpsexample.com/example-post-1.html) de l'ancienne URL du domaine actuel que vous souhaitez rester en vie. Remplacez ensuite chaque valeur par la partie chemin de la nouvelle URL du domaine actuel vers laquelle vous souhaitez rediriger

Toutes les redirections seront des redirections 301. Ceci peut être modifié en changeant
**301** dans le code ci-dessous à un code d'état de redirection HTTP différent tel que **302**


package main import ( "net/http""os""strings") func init() { http.HandleFunc handler) } func handler(w http.ResponseWriter, r *http.Request) { // True (ok) if request le chemin est dans la carte des urls si valeur, ok := urls[r.URL.Path] ; ok { value = domain + value http.Redirect(w, r, value, 301) } else { path := "static/"+ r.URL.Path // Renvoie 403 si la requête HTTP est destinée à un répertoire qui existe et existe ne contient pas de fichier index.html 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