Implementazione della multitenancy mediante gli spazi dei nomi

L'API Namespaces consente di abilitare facilmente la multitenancy nella tua applicazione, semplicemente selezionando una stringa dello spazio dei nomi per ogni tenant in web.xml utilizzando il pacchetto NamespaceManager.

Questa API è supportata per i runtime di prima generazione e può essere utilizzata durante l'upgrade ai runtime di seconda generazione corrispondenti. Se esegui l'aggiornamento al runtime Java 11/17 di App Engine, consulta la guida alla migrazione per conoscere le opzioni di migrazione per i servizi in bundle legacy.

Impostazione dello spazio dei nomi attuale

Puoi ottenere, impostare e convalidare gli spazi dei nomi utilizzando NamespaceManager. Il gestore dello spazio dei nomi consente di impostare uno spazio dei nomi attuale per le API abilitate per lo spazio dei nomi. Puoi impostare preventivamente uno spazio dei nomi attuale utilizzando web.xml e il datastore e memcache utilizzano automaticamente questo spazio dei nomi.

La maggior parte degli sviluppatori di App Engine utilizzerà il proprio dominio Google Workspace (in precedenza G Suite) come spazio dei nomi attuale. Google Workspace ti consente di eseguire il deployment della tua app in qualsiasi dominio di tua proprietà, quindi puoi utilizzare facilmente questo meccanismo per configurare diversi spazi dei nomi per domini diversi. Questi spazi dei nomi possono essere utilizzati per separare i dati tra i domini. Per ulteriori informazioni, consulta la sezione Mappatura di domini personalizzati.

Il seguente esempio di codice mostra come impostare lo spazio dei nomi attuale sul dominio Google Workspace utilizzato per mappare l'URL. In particolare, questa stringa sarà la stessa per tutti gli URL mappati tramite lo stesso dominio Google Workspace.

Prima di richiamare i metodi servlet, puoi impostare gli spazi dei nomi in Java utilizzando l'interfaccia Filtro servlet. Il seguente esempio semplice mostra come utilizzare il dominio Google Workspace come spazio dei nomi attuale:

// Filter to set the Google Apps domain as the namespace.
public class NamespaceFilter implements Filter {

  @Override
  public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
      throws IOException, ServletException {
    // Make sure set() is only called if the current namespace is not already set.
    if (NamespaceManager.get() == null) {
      // If your app is hosted on appspot, this will be empty. Otherwise it will be the domain
      // the app is hosted on.
      NamespaceManager.set(NamespaceManager.getGoogleAppsNamespace());
    }
    chain.doFilter(req, res); // Pass request back down the filter chain
  }

Il filtro dello spazio dei nomi deve essere configurato nel file web.xml. Tieni presente che, se ci sono più voci di filtro, il primo spazio dei nomi da impostare è quello che verrà utilizzato.

Il seguente esempio di codice mostra come configurare il filtro dello spazio dei nomi in web.xml:

<!-- Configure the namespace filter. -->
<filter>
    <filter-name>NamespaceFilter</filter-name>
    <filter-class>com.example.appengine.NamespaceFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>NamespaceFilter</filter-name>
    <url-pattern>/sign</url-pattern>
</filter-mapping>

Per informazioni più generali sul file web.xml e sulla mappatura dei percorsi degli URL ai servlet, consulta Il descrittore del deployment: web.xml.

Puoi anche impostare un nuovo spazio dei nomi per un'operazione temporanea, reimpostando lo spazio dei nomi originale al termine dell'operazione utilizzando il pattern try/finally mostrato di seguito:

// Set the namepace temporarily to "abc"
String oldNamespace = NamespaceManager.get();
NamespaceManager.set("abc");
try {
  //      ... perform operation using current namespace ...
} finally {
  NamespaceManager.set(oldNamespace);
}

Se non specifichi un valore per namespace, lo spazio dei nomi viene impostato su una stringa vuota. La stringa namespace è arbitraria, ma è limitata a un massimo di 100 caratteri alfanumerici, punti, trattini bassi e trattini. In modo più esplicito, le stringhe dello spazio dei nomi devono corrispondere all'espressione regolare [0-9A-Za-z._-]{0,100}.

Per convenzione, tutti gli spazi dei nomi che iniziano con "_" (trattino basso) sono riservati all'uso da parte del sistema. Questa regola per lo spazio dei nomi di sistema non viene applicata, ma se non la segui, potresti facilmente riscontrare conseguenze negative non definite.

Evitare fughe di dati

Uno dei rischi comunemente associati alle app multitenant è il pericolo che i dati vadano persi negli spazi dei nomi. Le fughe di dati involontarie possono derivare da molte origini, tra cui:

• Utilizzo di spazi dei nomi con API App Engine che non supportano ancora gli spazi dei nomi. Ad esempio, Blobstore non supporta gli spazi dei nomi. Se utilizzi Spazi dei nomi con Blobstore, devi evitare di utilizzare query Blobstore per le richieste degli utenti finali o chiavi Blobstore provenienti da fonti non attendibili.
• Utilizzo di un supporto di archiviazione esterno (anziché memcache e datastore), tramite URL Fetch o qualche altro meccanismo, senza fornire uno schema di compartimentazione per gli spazi dei nomi.
• Impostazione di uno spazio dei nomi basato sul dominio email di un utente. Nella maggior parte dei casi, non è consigliabile che tutti gli indirizzi email di un dominio accedano a uno spazio dei nomi. L'uso del dominio email impedisce inoltre all'applicazione di utilizzare uno spazio dei nomi finché l'utente non esegue l'accesso.

Deployment degli spazi dei nomi

Le seguenti sezioni descrivono come eseguire il deployment degli spazi dei nomi con altri strumenti e API di App Engine.

Creazione di spazi dei nomi in base all'utente

Alcune applicazioni devono creare spazi dei nomi in base all'utente. Se vuoi suddividere i dati a livello di utente per gli utenti che hanno eseguito l'accesso, ti consigliamo di utilizzare User.getUserId(), che restituisce un ID univoco e permanente per l'utente. Il seguente esempio di codice mostra come utilizzare l'API Users per questo scopo:

if (com.google.appengine.api.NamespaceManager.get() == null) {
  // Assuming there is a logged in user.
  namespace = UserServiceFactory.getUserService().getCurrentUser().getUserId();
  NamespaceManager.set(namespace);
}

In genere, le app che creano spazi dei nomi per singolo utente forniscono anche pagine di destinazione specifiche a utenti diversi. In questi casi, l'applicazione deve fornire uno schema URL che detta la pagina di destinazione da mostrare a un utente.

Utilizzo degli spazi dei nomi con Datastore

Per impostazione predefinita, il datastore utilizza l'impostazione dello spazio dei nomi attuale nel gestore dello spazio dei nomi per le richieste del datastore. L'API applica questo spazio dei nomi attuale agli oggetti Key o Query al momento della creazione. Di conseguenza, devi fare attenzione se un'applicazione archivia gli oggetti Key o Query in forma serializzata, poiché lo spazio dei nomi viene conservato in queste serializzazioni.

Se utilizzi oggetti Key e Query deserializzati, assicurati che si comportino come previsto. Le applicazioni più semplici che utilizzano il datastore (put/query/get) senza utilizzare altri meccanismi di archiviazione funzioneranno come previsto impostando lo spazio dei nomi attuale prima di chiamare qualsiasi API del datastore.

Nota: un'applicazione che legge chiavi o altri oggetti sensibili allo spazio dei nomi da fonti non attendibili (come il client del browser web) introduce vulnerabilità di sicurezza. Le applicazioni che si basano su chiavi provenienti da origini non attendibili devono incorporare un livello di sicurezza che verifichi che l'utente corrente sia autorizzato ad accedere allo spazio dei nomi richiesto.

Gli oggetti Query e Key mostrano i seguenti comportamenti unici in merito agli spazi dei nomi:

• Gli oggetti Query e Key ereditano lo spazio dei nomi attuale quando vengono creati, a meno che tu non imposti uno spazio dei nomi esplicito.
• Quando un'applicazione crea un nuovo Key da un predecessore, il nuovo Key eredita lo spazio dei nomi del predecessore.
• Non esiste un'API per Java per impostare esplicitamente lo spazio dei nomi di Key o Query.

Il seguente esempio di codice mostra il gestore di richieste SomeRequest per incrementare il conteggio per lo spazio dei nomi attuale e lo spazio dei nomi -global- con nome arbitrario in un'entità datastore Counter.

public class UpdateCountsServlet extends HttpServlet {

  private static final int NUM_RETRIES = 10;

  @Entity
  public class CounterPojo {

    @Id
    public Long id;
    @Index
    public String name;
    public Long count;

    public CounterPojo() {
      this.count = 0L;
    }

    public CounterPojo(String name) {
      this.name = name;
      this.count = 0L;
    }

    public void increment() {
      count++;
    }
  }

  /**
   * Increment the count in a Counter datastore entity.
   **/
  public long updateCount(String countName) {

    CounterPojo cp = ofy().load().type(CounterPojo.class).filter("name", countName).first().now();
    if (cp == null) {
      cp = new CounterPojo(countName);
    }
    cp.increment();
    ofy().save().entity(cp).now();

    return cp.count;
  }

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws java.io.IOException {

    // Update the count for the current namespace.
    updateCount("request");

    // Update the count for the "-global-" namespace.
    String namespace = NamespaceManager.get();
    try {
      // "-global-" is namespace reserved by the application.
      NamespaceManager.set("-global-");
      updateCount("request");
    } finally {
      NamespaceManager.set(namespace);
    }
    resp.setContentType("text/plain");
    resp.getWriter().println("Counts are now updated.");
  }

Utilizzo degli spazi dei nomi con memcache

Per impostazione predefinita, memcache utilizza lo spazio dei nomi attuale del gestore dello spazio dei nomi per le richieste memcache. Nella maggior parte dei casi, non è necessario impostare esplicitamente uno spazio dei nomi nella memcache e questo potrebbe introdurre bug imprevisti.

Tuttavia, ci sono alcune istanze univoche in cui è opportuno impostare esplicitamente uno spazio dei nomi nella memcache. Ad esempio, la tua applicazione potrebbe avere dati comuni condivisi tra tutti gli spazi dei nomi (ad esempio una tabella contenente i codici paese).

Avviso: se imposti esplicitamente uno spazio dei nomi in memcache, le impostazioni correnti del gestore dello spazio dei nomi verranno ignorate.

Lo snippet di codice riportato di seguito mostra come impostare esplicitamente lo spazio dei nomi in memcache:

Per impostazione predefinita, l'API memcache per Java esegue una query sul gestore dello spazio dei nomi per lo spazio dei nomi attuale da MemcacheService. Puoi anche indicare esplicitamente uno spazio dei nomi quando crei la memcache utilizzando getMemcacheService(Namespace). Per la maggior parte delle applicazioni non è necessario specificare esplicitamente uno spazio dei nomi.

Il seguente esempio di codice mostra come creare una memcache che utilizza lo spazio dei nomi attuale nel gestore dello spazio dei nomi.

// Create a MemcacheService that uses the current namespace by
// calling NamespaceManager.get() for every access.
MemcacheService current = MemcacheServiceFactory.getMemcacheService();

// stores value in namespace "abc"
oldNamespace = NamespaceManager.get();
NamespaceManager.set("abc");
try {
  current.put("key", value); // stores value in namespace “abc”
} finally {
  NamespaceManager.set(oldNamespace);
}

Questo esempio di codice specifica in modo esplicito uno spazio dei nomi durante la creazione di un servizio memcache:

// Create a MemcacheService that uses the namespace "abc".
MemcacheService explicit = MemcacheServiceFactory.getMemcacheService("abc");
explicit.put("key", value); // stores value in namespace "abc"

Utilizzo degli spazi dei nomi con la coda di attività

Per impostazione predefinita, le code in modalità push utilizzano lo spazio dei nomi attuale impostato nel gestore dello spazio dei nomi al momento della creazione dell'attività. Nella maggior parte dei casi, non è necessario impostare esplicitamente uno spazio dei nomi nella coda di attività e questo potrebbe introdurre bug imprevisti.

Avviso: le attività nelle code di pull non forniscono alcuna funzionalità dello spazio dei nomi. Se utilizzi gli spazi dei nomi con code in modalità pull, devi assicurarti che gli spazi dei nomi vengano salvati nel payload e ripristinati come necessario dall'applicazione.

I nomi delle attività sono condivisi tra tutti gli spazi dei nomi. Non puoi creare due attività con lo stesso nome, anche se utilizzano spazi dei nomi diversi. Se vuoi utilizzare lo stesso nome dell'attività per molti spazi dei nomi, puoi semplicemente aggiungere ogni spazio dei nomi al nome dell'attività.

Quando una nuova attività chiama il metodo add() della coda di attività, la coda di attività copia lo spazio dei nomi attuale e, se applicabile, il dominio Google Workspace dal gestore dello spazio dei nomi. Quando l'attività viene eseguita, lo spazio dei nomi attuale e quello di Google Workspace vengono ripristinati.

Se lo spazio dei nomi attuale non è impostato nella richiesta di origine (in altre parole, se get() restituisce null), la coda di attività imposta lo spazio dei nomi su "" nelle attività eseguite.

Esistono alcune istanze univoche in cui è opportuno impostare esplicitamente uno spazio dei nomi per un'attività che funziona in tutti gli spazi dei nomi. Ad esempio, potresti creare un'attività che aggrega le statistiche sull'utilizzo per tutti gli spazi dei nomi. Puoi quindi impostare esplicitamente lo spazio dei nomi dell'attività. Il seguente esempio di codice mostra come impostare esplicitamente gli spazi dei nomi con la coda di attività.

Innanzitutto, crea un gestore di coda di attività che incrementi il conteggio in un'entità datastore Counter:

public class UpdateCountsServlet extends HttpServlet {

  private static final int NUM_RETRIES = 10;

  @Entity
  public class CounterPojo {

    @Id
    public Long id;
    @Index
    public String name;
    public Long count;

    public CounterPojo() {
      this.count = 0L;
    }

    public CounterPojo(String name) {
      this.name = name;
      this.count = 0L;
    }

    public void increment() {
      count++;
    }
  }

  /**
   * Increment the count in a Counter datastore entity.
   **/
  public long updateCount(String countName) {

    CounterPojo cp = ofy().load().type(CounterPojo.class).filter("name", countName).first().now();
    if (cp == null) {
      cp = new CounterPojo(countName);
    }
    cp.increment();
    ofy().save().entity(cp).now();

    return cp.count;
  }

e,

// called from Task Queue
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
  String[] countName = req.getParameterValues("countName");
  if (countName.length != 1) {
    resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
    return;
  }
  updateCount(countName[0]);
}

Quindi, crea attività con un servlet:

public class SomeRequestServlet extends HttpServlet {

  // Handler for URL get requests.
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {

    // Increment the count for the current namespace asynchronously.
    QueueFactory.getDefaultQueue()
        .add(TaskOptions.Builder.withUrl("/_ah/update_count").param("countName", "SomeRequest"));
    // Increment the global count and set the
    // namespace locally.  The namespace is
    // transferred to the invoked request and
    // executed asynchronously.
    String namespace = NamespaceManager.get();
    try {
      NamespaceManager.set("-global-");
      QueueFactory.getDefaultQueue()
          .add(TaskOptions.Builder.withUrl("/_ah/update_count").param("countName", "SomeRequest"));
    } finally {
      NamespaceManager.set(namespace);
    }
    resp.setContentType("text/plain");
    resp.getWriter().println("Counts are being updated.");
  }
}

Utilizzo degli spazi dei nomi con Blobstore

Il Blobstore non è segmentato per spazio dei nomi. Per mantenere uno spazio dei nomi in Blobstore, devi accedere a Blobstore tramite un supporto di archiviazione che conosca lo spazio dei nomi (attualmente solo memcache, datastore e coda di attività). Ad esempio, se il Key di un BLOB viene archiviato in un'entità datastore, puoi accedervi con un datastore Key o Query che conosca lo spazio dei nomi.

Se l'applicazione accede al Blobstore tramite chiavi archiviate in uno spazio di archiviazione sensibile allo spazio dei nomi, il Blobstore non deve essere segmentato per spazio dei nomi. Le applicazioni devono evitare fughe di BLOB tra gli spazi dei nomi:

• Non utilizzare com.google.appengine.api.blobstore.BlobInfoFactory per le richieste degli utenti finali. Puoi utilizzare le query BlobInfo per le richieste amministrative (ad esempio per generare report su tutti i BLOB delle applicazioni), ma il loro utilizzo per le richieste degli utenti finali potrebbe causare fughe di dati, perché tutti i record BlobInfo non sono compartimentati per spazio dei nomi.
• Non utilizzano chiavi Blobstore da fonti non attendibili.

Impostazione degli spazi dei nomi per le query Datastore

Nella console Google Cloud, puoi impostare lo spazio dei nomi per le query Datastore.

Se non vuoi utilizzare quello predefinito, seleziona dal menu a discesa quello che vuoi usare.

Utilizzo degli spazi dei nomi con il caricatore collettivo

Il caricatore collettivo supporta un flag --namespace=NAMESPACE che consente di specificare lo spazio dei nomi da utilizzare. Ogni spazio dei nomi viene gestito separatamente e, se vuoi accedervi, dovrai eseguirne l'iterazione.

Utilizzare gli spazi dei nomi con la Ricerca

Una nuova istanza di Index eredita lo spazio dei nomi dell'elemento SearchService utilizzato per crearla. Una volta creato un riferimento a un indice, il suo spazio dei nomi non può essere modificato. Esistono due modi per impostare lo spazio dei nomi per un SearchService prima di utilizzarlo per creare un indice:

• Per impostazione predefinita, un nuovo SearchService utilizza lo spazio dei nomi attuale. Puoi impostare lo spazio dei nomi attuale prima di creare il servizio:

// Set the current namespace to "aSpace"
NamespaceManager.set("aSpace");
// Create a SearchService with the namespace "aSpace"
SearchService searchService = SearchServiceFactory.getSearchService();
// Create an IndexSpec
IndexSpec indexSpec = IndexSpec.newBuilder().setName("myIndex").build();
// Create an Index with the namespace "aSpace"
Index index = searchService.getIndex(indexSpec);

Durante la creazione di un servizio, puoi specificare uno spazio dei nomi in SearchServiceConfig:

// Create a SearchServiceConfig, specifying the namespace "anotherSpace"
SearchServiceConfig config =
    SearchServiceConfig.newBuilder().setNamespace("anotherSpace").build();
// Create a SearchService with the namespace "anotherSpace"
searchService = SearchServiceFactory.getSearchService(config);
// Create an IndexSpec
indexSpec = IndexSpec.newBuilder().setName("myindex").build();
// Create an Index with the namespace "anotherSpace"
index = searchService.getIndex(indexSpec);