Utiliser Cloud Firestore en mode Datastore

Conçue pour le scaling automatique et les hautes performances, Firestore est une base de données de documents NoSQL qui simplifie le développement d'applications. Il s'agit de la dernière version de Datastore, qui introduit plusieurs améliorations.

Étant donné que Cloud Firestore en mode Datastore est optimisé pour les cas d'utilisation des serveurs et pour App Engine, nous vous recommandons d'utiliser ce mode pour les bases de données qui sont principalement utilisées par les applications App Engine. Firestore en mode natif est particulièrement utile pour les cas d'utilisation de notifications mobiles et en temps réel. Pour en savoir plus sur les modes de Firestore, consultez la page Choisir entre le mode natif et le mode Datastore.

Ce document décrit comment utiliser la bibliothèque cliente Google Cloud pour stocker et récupérer des données dans une base de données en mode Datastore.

Prérequis et configuration

Suivez les instructions de la section "Hello, World!" pour Go sur App Engine pour configurer votre environnement et votre projet, et pour comprendre la structure des applications Go dans App Engine. Notez et enregistrez votre ID de projet. Il vous servira à exécuter l'exemple d'application décrit dans ce document.

Cloner le dépôt

Téléchargez (clonez) l'exemple suivant :

go get -d -v github.com/GoogleCloudPlatform/golang-samples/datastore
cd $GOPATH/src/github.com/GoogleCloudPlatform/golang-samples/appengine_flexible/datastore

Modifier la configuration du projet et définir les dépendances

Dans app.yaml, définissez GCLOUD_DATASET_ID pour votre projet. Il s'agit de votre ID de projet.

appengine_flexible/datastore/app.yaml 
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

runtime: go
env: flex

automatic_scaling:
  min_num_instances: 1

env_variables:
  GCLOUD_DATASET_ID: your-project-id

Code d'application

L'exemple d'application enregistre, récupère et affiche les adresses IP des visiteurs. Vous noterez qu'une entrée de journal est une classe simple à deux champs à laquelle le type visit est attribué et qui est enregistrée en mode Datastore à l'aide de la commande datastore put du client Datastore. Ensuite, les dix visites les plus récentes sont extraites par ordre décroissant à l'aide des commandes NewQuery et GetAll du client Datastore.

appengine_flexible/datastore/datastore.go 

// Sample datastore demonstrates use of the cloud.google.com/go/datastore package from App Engine flexible.
package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"

	"cloud.google.com/go/datastore"
	"google.golang.org/appengine"
)

var datastoreClient *datastore.Client

func main() {
	ctx := context.Background()

	// Set this in app.yaml when running in production.
	projectID := os.Getenv("GCLOUD_DATASET_ID")

	var err error
	datastoreClient, err = datastore.NewClient(ctx, projectID)
	if err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("/", handle)
	appengine.Main()
}

func handle(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}

	ctx := context.Background()

	// Get a list of the most recent visits.
	visits, err := queryVisits(ctx, 10)
	if err != nil {
		msg := fmt.Sprintf("Could not get recent visits: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	// Record this visit.
	if err := recordVisit(ctx, time.Now(), r.RemoteAddr); err != nil {
		msg := fmt.Sprintf("Could not save visit: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	fmt.Fprintln(w, "Previous visits:")
	for _, v := range visits {
		fmt.Fprintf(w, "[%s] %s\n", v.Timestamp, v.UserIP)
	}
	fmt.Fprintln(w, "\nSuccessfully stored an entry of the current request.")
}

type visit struct {
	Timestamp time.Time
	UserIP    string
}

func recordVisit(ctx context.Context, now time.Time, userIP string) error {
	v := &visit{
		Timestamp: now,
		UserIP:    userIP,
	}

	k := datastore.IncompleteKey("Visit", nil)

	_, err := datastoreClient.Put(ctx, k, v)
	return err
}

func queryVisits(ctx context.Context, limit int64) ([]*visit, error) {
	// Print out previous visits.
	q := datastore.NewQuery("Visit").
		Order("-Timestamp").
		Limit(10)

	visits := make([]*visit, 0)
	_, err := datastoreClient.GetAll(ctx, q, &visits)
	return visits, err
}

Utiliser des fichiers index.yaml

L'exemple d'application effectue des requêtes simples. Les requêtes Datastore plus élaborées nécessitent un ou plusieurs index, que vous devez spécifier dans un fichier index.yaml à importer avec l'application. Ce fichier peut être créé manuellement ou généré automatiquement lors du test en local de votre application.

Test local

Si vous devez développer et tester votre application en local, vous pouvez utiliser l'émulateur en mode Datastore.

Plus d'informations

Pour obtenir des informations complètes sur le mode Datastore, y compris sur les optimisations et les concepts, consultez la documentation sur Firestore en mode Datastore.