Implementazione del multitenancy utilizzando Namespaces

Go Java PHP Python

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

Impostazione dello spazio dei nomi attuale

Puoi ottenere, impostare e convalidare gli spazi dei nomi utilizzando il pacchetto NamespaceManager. Il gestore dello spazio dei nomi ti consente di impostare uno spazio dei nomi corrente per le API abilitate per lo spazio dei nomi. Imposti uno spazio dei nomi corrente in anticipo in web.xml e Datastore e memcache utilizzano automaticamente questo spazio dei nomi.

La maggior parte degli sviluppatori di App Engine utilizzerà il proprio dominio Google Workspace (precedentemente G Suite) come spazio dei nomi corrente. Google Workspace ti consente di eseguire il deployment della tua app in qualsiasi dominio di tua proprietà, in modo da poter utilizzare facilmente questo meccanismo per configurare spazi dei nomi diversi per domini diversi. Poi, puoi utilizzare questi spazi dei nomi separati per separare i dati nei vari domini. Per ulteriori informazioni, vedi Mappatura di domini personalizzati.

Il seguente esempio di codice mostra come impostare lo spazio dei nomi corrente 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.

Puoi impostare gli spazi dei nomi in Java utilizzando l'interfaccia del filtro servlet prima di richiamare i metodi servlet. Il seguente esempio di codice mostra come utilizzare il tuo dominio Google Workspace come spazio dei nomi corrente:

// 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 sono presenti più voci di filtro, verrà utilizzato il primo spazio dei nomi impostato.

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 sul mapping dei percorsi URL ai servlet, consulta The Deployment Descriptor: 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 è anche limitata a un massimo di 100 caratteri alfanumerici, punti, trattini bassi e trattini. Più precisamente, 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 di sistema. Questa regola dello spazio dei nomi di sistema non viene applicata, ma potresti facilmente riscontrare conseguenze negative non definite se non la rispetti.

Evitare le fughe di dati

Uno dei rischi comunemente associati alle app multitenant è il pericolo che i dati vengano divulgati tra gli spazi dei nomi. Le fughe di dati non intenzionali possono verificarsi da molte fonti, 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 gli spazi dei nomi con Blobstore, devi evitare di utilizzare query Blobstore per le richieste degli utenti finali o chiavi Blobstore da origini non attendibili.
• Utilizzo di un supporto di archiviazione esterno (anziché memcache e Datastore), tramite URL Fetch o un altro meccanismo, senza fornire uno schema di compartimentazione per gli spazi dei nomi.
• Impostazione di uno spazio dei nomi in base al dominio email di un utente. Nella maggior parte dei casi, non vuoi che tutti gli indirizzi email di un dominio accedano a uno spazio dei nomi. L'utilizzo del dominio email impedisce inoltre alla tua applicazione di utilizzare uno spazio dei nomi finché l'utente non ha eseguito l'accesso.

Deployment degli spazi dei nomi

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

Creazione di spazi dei nomi per utente

Alcune applicazioni devono creare spazi dei nomi in base all'utente. Se vuoi compartimentare i dati a livello di utente per gli utenti che hanno eseguito l'accesso, valuta la possibilità 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 a 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 in base all'utente forniscono anche pagine di destinazione specifiche a utenti diversi. In questi casi, l'applicazione deve fornire uno schema URL che determini quale pagina di destinazione mostrare a un utente.

Utilizzo degli spazi dei nomi con Datastore

Per impostazione predefinita, Datastore utilizza l'impostazione dello spazio dei nomi corrente nel gestore dello spazio dei nomi per le richieste Datastore. L'API applica questo spazio dei nomi corrente agli oggetti Key o Query quando vengono creati. Pertanto, devi prestare attenzione se un'applicazione archivia oggetti Key o Query in forme serializzate, poiché lo spazio dei nomi viene conservato in queste serializzazioni.

Se utilizzi oggetti Key e Query deserializzati, assicurati che funzionino come previsto. La maggior parte delle applicazioni semplici che utilizzano Datastore (put/query/get) senza utilizzare altri meccanismi di archiviazione funzionerà come previsto impostando lo spazio dei nomi corrente prima di chiamare qualsiasi API 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 fonti non attendibili devono incorporare un livello di sicurezza che verifichi che l'utente attuale sia autorizzato ad accedere allo spazio dei nomi richiesto.

Gli oggetti Query e Key mostrano i seguenti comportamenti univoci in relazione agli spazi dei nomi:

• Gli oggetti Query e Key ereditano lo spazio dei nomi corrente al momento della creazione, a meno che non ne imposti uno esplicito.
• Quando un'applicazione crea un nuovo Key da un elemento principale, il nuovo Key eredita lo spazio dei nomi dell'elemento principale.
• Non esiste un'API per Java per impostare esplicitamente lo spazio dei nomi di un Key o di un Query.

L'esempio di codice seguente mostra il gestore delle richieste SomeRequest per incrementare il conteggio per lo spazio dei nomi corrente e lo spazio dei nomi denominato arbitrariamente -global- 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 corrente di Namespace Manager per le richieste memcache. Nella maggior parte dei casi, non è necessario impostare esplicitamente uno spazio dei nomi nella memcache e questa operazione potrebbe introdurre bug imprevisti.

Tuttavia, esistono alcuni casi unici in cui è opportuno impostare esplicitamente uno spazio dei nomi nella memcache. Ad esempio, la tua applicazione potrebbe avere dati comuni condivisi in tutti gli spazi dei nomi (ad esempio una tabella contenente i codici paese).

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

Il seguente snippet di codice mostra come impostare in modo esplicito lo spazio dei nomi nella memcache:

Per impostazione predefinita, l'API memcache per Java esegue query sul gestore dello spazio dei nomi per lo spazio dei nomi corrente da MemcacheService. Puoi anche dichiarare 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 corrente nel gestore degli spazi 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 push utilizzano lo spazio dei nomi corrente impostato in Gestione spazi 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 questa operazione potrebbe introdurre bug imprevisti.

Avviso :le attività nelle code pull non forniscono alcuna funzionalità di spazio dei nomi. Se utilizzi gli spazi dei nomi con le code pull, devi assicurarti che vengano salvati nel payload e ripristinati in base alle esigenze dell'applicazione.

I nomi delle attività vengono condivisi in 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 di attività per molti spazi dei nomi, puoi semplicemente aggiungere ogni spazio dei nomi al nome dell'attività.

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

Se lo spazio dei nomi corrente 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 alcuni casi unici in cui è opportuno impostare esplicitamente uno spazio dei nomi per un'attività che funziona in tutti gli spazi dei nomi. Ad esempio, puoi creare un'attività che aggrega le statistiche di utilizzo in tutti gli spazi dei nomi. A questo punto, puoi impostare esplicitamente lo spazio dei nomi dell'attività.

Per prima cosa, 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]);
}

Poi, crea attività con una 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

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

Se l'applicazione accede a Blobstore tramite chiavi archiviate in uno spazio di archiviazione sensibile allo spazio dei nomi, Blobstore stesso non deve essere segmentato per spazio dei nomi. Le applicazioni devono evitare perdite di blob tra spazi dei nomi:

• Non utilizza 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 utilizzarle per le richieste degli utenti finali potrebbe comportare perdite di dati perché tutti i record BlobInfo non sono suddivisi per spazio dei nomi.
• Non utilizzare chiavi Blobstore provenienti da fonti non attendibili.

Impostazione degli spazi dei nomi per le query Datastore

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

Se non vuoi utilizzare quello predefinito, seleziona lo spazio dei nomi che vuoi utilizzare dal menu a discesa.

Utilizzo degli spazi dei nomi con Bulk Loader

Il caricatore collettivo supporta un flag --namespace=NAMESPACE che ti consente di specificare lo spazio dei nomi da utilizzare. Ogni spazio dei nomi viene gestito separatamente e, se vuoi accedere a tutti gli spazi dei nomi, devi iterarli.

Utilizzare gli spazi dei nomi con la ricerca

Una nuova istanza di Index eredita lo spazio dei nomi di SearchService utilizzato per crearla. Una volta creato un riferimento a un indice, il relativo 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 prende lo spazio dei nomi corrente. Puoi impostare lo spazio dei nomi corrente 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);

• Puoi specificare uno spazio dei nomi in SearchServiceConfig quando crei un servizio:

// 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);