Wie lösche ich alle Datenspeicher in Google App Engine?

Weiß jemand, wie man alle Datenspeicher in Google App Engine löscht ?

Wenn Sie über den Live-Datenspeicher sprechen , öffnen Sie das Dashboard für Ihre App (melden Sie sich bei Appengine an), dann Datenspeicher -> Dataviewer, wählen Sie alle Zeilen für die Tabelle aus, die Sie löschen möchten, und klicken Sie auf die Schaltfläche Löschen (Sie müssen) tun Sie dies für alle Ihre Tabellen). Sie können dasselbe programmgesteuert über remote_api tun (aber ich habe es nie verwendet).

Wenn Sie über den Entwicklungsdatenspeicher sprechen , müssen Sie nur die folgende Datei löschen: "./WEB-INF/appengine-generated/local_db.bin" . Die Datei wird beim nächsten Ausführen des Entwicklungsservers erneut für Sie generiert und Sie haben eine eindeutige Datenbank.

Stellen Sie sicher, dass Sie Ihr Projekt anschließend reinigen.

Dies ist eine der kleinen Fallstricke, die nützlich sind, wenn Sie mit der Google Application Engine spielen. Sie werden feststellen, dass Objekte im Datenspeicher persistieren und dann das JDO-Objektmodell für Ihre persistenten Entitäten ändern, was zu veralteten Daten führt, die Ihre App überall zum Absturz bringen.

Der beste Ansatz ist die von Nick vorgeschlagene Remote-API-Methode. Er ist ein App Engine- Ingenieur von Google . Vertrauen Sie ihm also.

Dies ist nicht so schwierig, und das neueste 1.2.5 SDK bietet die Datei remote_shell_api.py ab Lager. Laden Sie das neue SDK herunter. Folgen Sie dann den Schritten:

• Remote-Server in Ihrer Befehlszeile verbinden: remote_shell_api.py yourapp /remote_api Die Shell fragt nach Ihren Anmeldeinformationen und erstellt, falls autorisiert, eine Python-Shell für Sie. Sie benötigen den Setup-URL-Handler für / remote_api in Ihrer app.yaml

• Wenn Sie die Entitäten abrufen, die Sie löschen möchten, sieht der Code folgendermaßen aus:

    from models import Entry
    query = Entry.all(keys_only=True)
    entries =query.fetch(1000)
    db.delete(entries)
    \# This could bulk delete 1000 entities a time

Update 28.10.2013 :

• remote_shell_api.pywurde durch ersetzt remote_api_shell.pyund Sie sollten sich remote_api_shell.py -s your_app_id.appspot.comgemäß der Dokumentation mit verbinden .

• Es gibt eine neue experimentelle Funktion Datastore Admin . Nachdem Sie sie in den App-Einstellungen aktiviert haben, können Sie Ihren Datenspeicher über die Web-Benutzeroberfläche löschen und sichern.

Der schnellste und effizienteste Weg, um das Löschen von Massen im Datenspeicher zu handhaben, ist die Verwendung der neuen Mapper-API , die in der neuesten Google-E / A angekündigt wurde .

Wenn Ihre bevorzugte Sprache Python ist , müssen Sie Ihren Mapper nur in einer Datei mapreduce.yaml registrieren und eine Funktion wie die folgende definieren:

from mapreduce import operation as op
def process(entity):
 yield op.db.Delete(entity)

Unter Java sollten Sie sich diesen Artikel ansehen, der eine Funktion wie diese vorschlägt:

@Override
public void map(Key key, Entity value, Context context) {
    log.info("Adding key to deletion pool: " + key);
    DatastoreMutationPool mutationPool = this.getAppEngineContext(context)
            .getMutationPool();
    mutationPool.delete(value.getKey());
}

EDIT:
Seit SDK 1.3.8 gibt es eine Datenspeicher - Admin - Funktion für diesen Zweck

Sie können den Entwicklungsserver-Datenspeicher löschen, wenn Sie den Server ausführen:

/path/to/dev_appserver.py --clear_datastore=yes myapp

Sie können auch abkürzen --clear_datastoremit -c.

Wenn Sie über eine erhebliche Datenmenge verfügen, müssen Sie ein Skript verwenden, um diese zu löschen. Sie können remote_api jedoch verwenden, um den Datenspeicher auf einfache Weise von der Clientseite zu löschen.

Los geht's: Gehen Sie zu Datastore Admin, wählen Sie den zu löschenden Entitätstyp aus und klicken Sie auf Löschen. Mapreduce kümmert sich um das Löschen!

Es gibt verschiedene Möglichkeiten, um Einträge aus dem Datenspeicher von App Engine zu entfernen:

1. Überlegen Sie zunächst, ob Sie wirklich Einträge entfernen müssen. Dies ist teuer und möglicherweise billiger, wenn Sie sie nicht entfernen.

2. Sie können alle Einträge manuell mit dem Datenspeicheradministrator löschen.

3. Sie können die Remote-API verwenden und Einträge interaktiv entfernen.

4. Sie können die Einträge programmgesteuert mit einigen Codezeilen entfernen.

5. Sie können sie mithilfe von Task-Warteschlangen und Cursorn in großen Mengen entfernen.

6. Oder Sie können Mapreduce verwenden, um etwas robusteres und schickeres zu erhalten.

Jede dieser Methoden wird im folgenden Blogbeitrag erläutert: http://www.shiftedup.com/2015/03/28/how-to-bulk-delete-entries-in-app-engine-datastore

Ich hoffe es hilft!

Die Null-Setup-Methode hierfür besteht darin, eine HTTP-Anforderung zum Ausführen eines beliebigen Codes an den Verwaltungsdienst zu senden, über den Ihre laufende App bereits automatisch verfügt:

import urllib
import urllib2

urllib2.urlopen('http://localhost:8080/_ah/admin/interactive/execute',
    data = urllib.urlencode({'code' : 'from google.appengine.ext import db\n' +
                                      'db.delete(db.Query())'}))

Quelle

Ich habe das von http://code.google.com/appengine/articles/remote_api.html .

Erstellen Sie die interaktive Konsole

Zunächst müssen Sie eine interaktive Appenginge-Konsole definieren. Erstellen Sie also eine Datei mit dem Namen appengine_console.py und geben Sie Folgendes ein:

#!/usr/bin/python
import code
import getpass
import sys

# These are for my OSX installation. Change it to match your google_appengine paths. sys.path.append("/Applications/GoogleAppEngineLauncher.app/Contents/Resources/GoogleAppEngine-default.bundle/Contents/Resources/google_appengine")
sys.path.append("/Applications/GoogleAppEngineLauncher.app/Contents/Resources/GoogleAppEngine-default.bundle/Contents/Resources/google_appengine/lib/yaml/lib")

from google.appengine.ext.remote_api import remote_api_stub
from google.appengine.ext import db

def auth_func():
  return raw_input('Username:'), getpass.getpass('Password:')

if len(sys.argv) < 2:
  print "Usage: %s app_id [host]" % (sys.argv[0],)
app_id = sys.argv[1]
if len(sys.argv) > 2:
  host = sys.argv[2]
else:
  host = '%s.appspot.com' % app_id

remote_api_stub.ConfigureRemoteDatastore(app_id, '/remote_api', auth_func, host)

code.interact('App Engine interactive console for %s' % (app_id,), None, locals())

Erstellen Sie die Mapper-Basisklasse

Sobald dies geschehen ist, erstellen Sie diese Mapper-Klasse. Ich habe gerade eine neue Datei namens utils.py erstellt und diese geworfen:

class Mapper(object):
  # Subclasses should replace this with a model class (eg, model.Person).
  KIND = None

  # Subclasses can replace this with a list of (property, value) tuples to filter by.
  FILTERS = []

  def map(self, entity):
    """Updates a single entity.

    Implementers should return a tuple containing two iterables (to_update, to_delete).
    """
    return ([], [])

  def get_query(self):
    """Returns a query over the specified kind, with any appropriate filters applied."""
    q = self.KIND.all()
    for prop, value in self.FILTERS:
      q.filter("%s =" % prop, value)
    q.order("__key__")
    return q

  def run(self, batch_size=100):
    """Executes the map procedure over all matching entities."""
    q = self.get_query()
    entities = q.fetch(batch_size)
    while entities:
      to_put = []
      to_delete = []
      for entity in entities:
        map_updates, map_deletes = self.map(entity)
        to_put.extend(map_updates)
        to_delete.extend(map_deletes)
      if to_put:
        db.put(to_put)
      if to_delete:
        db.delete(to_delete)
      q = self.get_query()
      q.filter("__key__ >", entities[-1].key())
      entities = q.fetch(batch_size)

Mapper soll nur eine abstrakte Klasse sein, mit der Sie jede Entität einer bestimmten Art durchlaufen können, sei es, um ihre Daten zu extrahieren oder um sie zu ändern und die aktualisierten Entitäten wieder im Datenspeicher zu speichern.

Lauf damit!

Starten Sie jetzt Ihre interaktive Appengine-Konsole:

$python appengine_console.py <app_id_here>

Damit sollte die interaktive Konsole gestartet werden. Erstellen Sie darin eine Unterklasse von Modell:

from utils import Mapper
# import your model class here 
class MyModelDeleter(Mapper):
    KIND = <model_name_here>

    def map(self, entity):
        return ([], [entity])

Führen Sie es schließlich aus (von Ihrer interaktiven Konsole aus): mapper = MyModelDeleter () mapper.run ()

Das ist es!

Sie können dies über die Weboberfläche tun. Melden Sie sich in Ihrem Konto an und navigieren Sie mit Links auf der linken Seite. In der Datenspeicherverwaltung haben Sie Optionen zum Ändern und Löschen von Daten. Verwenden Sie die entsprechenden Optionen.

Ich habe ein Add-In-Panel erstellt, das mit Ihren bereitgestellten App Engine-Apps verwendet werden kann. Es listet die Arten auf, die im Datenspeicher in einer Dropdown-Liste vorhanden sind, und Sie können auf eine Schaltfläche klicken, um "Aufgaben" zu planen, mit denen alle Entitäten einer bestimmten Art oder einfach alles gelöscht werden. Sie können es hier herunterladen:
http://code.google.com/p/jobfeed/wiki/Nuke

Für Python enthält 1.3.8 einen experimentellen Administrator, der dafür integriert ist. Sie sagen : "Aktivieren Sie die folgende integrierte Datei in Ihrer app.yaml-Datei:"

builtins:
- datastore_admin: on

"Das Löschen von Datenspeichern ist derzeit nur mit der Python-Laufzeit verfügbar. Java-Anwendungen können diese Funktion jedoch weiterhin nutzen, indem sie eine nicht standardmäßige Python-Anwendungsversion erstellen, die Datastore Admin in der Datei app.yaml aktiviert. Native Unterstützung für Java wird eingeschlossen in einer kommenden Veröffentlichung. "

Öffnen Sie "Datastore Admin" für Ihre Anwendung und aktivieren Sie Admin. Dann werden alle Ihre Entitäten mit Kontrollkästchen aufgelistet. Sie können einfach die unerwünschten Entites auswählen und löschen.

Das ist was Sie suchen ...

db.delete(Entry.all(keys_only=True))

Das Ausführen einer Nur-Schlüssel-Abfrage ist viel schneller als ein vollständiger Abruf, und Ihr Kontingent wird weniger stark beeinträchtigt, da Nur-Schlüssel-Abfragen als kleine Operationen betrachtet werden.

Hier ist ein Link zu einer Antwort von Nick Johnson, die es weiter beschreibt.

Unten finden Sie eine End-to-End-REST-API-Lösung zum Abschneiden einer Tabelle ...

Ich habe eine REST-API eingerichtet, um Datenbanktransaktionen zu verarbeiten, bei denen Routen direkt dem richtigen Modell / der richtigen Aktion zugeordnet werden. Dies kann durch Eingabe der richtigen URL (example.com/inventory/truncate) und Anmelden aufgerufen werden.

Hier ist die Route:

Route('/inventory/truncate', DataHandler, defaults={'_model':'Inventory', '_action':'truncate'})

Hier ist der Handler:

class DataHandler(webapp2.RequestHandler):
  @basic_auth
  def delete(self, **defaults):
    model = defaults.get('_model')
    action = defaults.get('_action')
    module = __import__('api.models', fromlist=[model])
    model_instance = getattr(module, model)()
    result = getattr(model_instance, action)()

Es beginnt mit dem dynamischen Laden des Modells (dh Inventar unter api.models) und ruft dann die richtige Methode (Inventory.truncate ()) auf, wie im Aktionsparameter angegeben.

Das @basic_auth ist ein Dekorator / Wrapper, der die Authentifizierung für vertrauliche Vorgänge (dh POST / DELETE) bereitstellt. Es gibt auch einen oAuth-Dekorateur , wenn Sie sich um die Sicherheit sorgen .

Schließlich heißt die Aktion:

def truncate(self):
  db.delete(Inventory.all(keys_only=True))

Es sieht aus wie Magie, ist aber eigentlich sehr einfach. Das Beste daran ist, dass delete () wiederverwendet werden kann, um das Löschen von einem oder mehreren Ergebnissen durch Hinzufügen einer weiteren Aktion zum Modell zu handhaben.

Sie können alle Datenspeicher löschen, indem Sie alle Arten einzeln löschen. mit Google Appengine Dashboard. Bitte befolgen Sie diese Schritte.

1. Melden Sie sich bei https://console.cloud.google.com/datastore/settings an
2. Klicken Sie auf Open Datastore Admin . (Aktivieren Sie es, wenn es nicht aktiviert ist.)
3. Wählen Sie alle Entitäten aus und klicken Sie auf Löschen. (Führen Sie in diesem Schritt einen Kartenreduzierungsjob aus, um alle ausgewählten Arten zu löschen.)

Weitere Informationen finden Sie unter Dieses Bild unter http://storage.googleapis.com/bnifsc/Screenshot%20from%202015-01-31%2023%3A58%3A41.png

Wenn Sie viele Daten haben, kann die Verwendung der Weboberfläche zeitaufwändig sein. Mit dem App Engine Launcher- Dienstprogramm können Sie alles auf einmal löschen, indem Sie das Kontrollkästchen "Datenspeicher beim Start löschen" aktivieren. Dieses Dienstprogramm ist jetzt sowohl für Windows als auch für Mac (Python-Framework) verfügbar.

Für den Entwicklungsserver können Sie den Server nicht über den Google App Engine Launcher ausführen, sondern vom Terminal aus wie folgt ausführen:

dev_appserver.py --port = [Portnummer] --clear_datastore = yes [Name der Anwendung]

Beispiel: Meine Anwendung "reader" wird auf Port 15080 ausgeführt. Nachdem Sie den Code geändert und den Server neu gestartet haben, führe ich einfach "dev_appserver.py --port = 15080 --clear_datastore = yes reader" aus.

Das ist gut für mich.

Antwort über die jüngsten Entwicklungen hinzufügen.

Google hat kürzlich die Verwaltungsfunktion für Datenspeicher hinzugefügt. Mit dieser Konsole können Sie Ihre Entitäten sichern, löschen oder in eine andere App kopieren.

https://developers.google.com/appengine/docs/adminconsole/datastoreadmin#Deleting_Entities_in_Bulk

Ich möchte oft nicht den gesamten Datenspeicher löschen, daher ziehe ich eine saubere Kopie von /war/WEB-INF/local_db.bin aus der Quellcodeverwaltung. Es mag nur ich sein, aber es scheint, dass ich die Datei auch bei gestopptem Dev-Modus physisch entfernen muss, bevor ich sie abrufe. Dies ist unter Windows mit dem Subversion-Plugin für Eclipse möglich.

PHP-Variation:

import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.DatastoreServiceFactory;

define('DATASTORE_SERVICE', DatastoreServiceFactory::getDatastoreService());

function get_all($kind) {
    $query = new Query($kind);
    $prepared = DATASTORE_SERVICE->prepare($query);
    return $prepared->asIterable();
}

function delete_all($kind, $amount = 0) {
    if ($entities = get_all($kind)) {
        $r = $t = 0;
        $delete = array();
        foreach ($entities as $entity) {
            if ($r < 500) {
                $delete[] = $entity->getKey();
            } else {
                DATASTORE_SERVICE->delete($delete);
                $delete = array();
                $r = -1;
            }
            $r++; $t++;
            if ($amount && $amount < $t) break;
        }
        if ($delete) {
            DATASTORE_SERVICE->delete($delete);
        }
    }
}

Ja, es wird einige Zeit und 30 Sekunden dauern. ist eine Grenze. Ich denke darüber nach, ein Ajax-App-Beispiel zu erstellen, um es über 30 Sekunden hinaus zu automatisieren.

for amodel in db.Model.__subclasses__():
                dela=[]
                print amodel
                try:
                    m = amodel()
                    mq = m.all()
                    print mq.count()
                    for mw in mq:
                        dela.append(mw)
                    db.delete(dela)
            #~ print len(dela)

                except:
                    pass

Wenn Sie ndb verwenden, die Methode, die für mich zum Löschen des Datenspeichers funktioniert hat:

ndb.delete_multi(ndb.Query(default_options=ndb.QueryOptions(keys_only=True)))

Für jeden Datenspeicher, der sich in der App Engine befindet und nicht lokal, können Sie die neue Datenspeicher-API verwenden . Hier ist eine Einführung für den Einstieg .

Ich habe ein Skript geschrieben, das alle nicht eingebauten Entitäten löscht. Die API ändert sich ziemlich schnell, daher habe ich sie als Referenz bei Commit 990ab5c7f2063e8147bcc56ee222836fd3d6e15b geklont

from gcloud import datastore
from gcloud.datastore import SCOPE
from gcloud.datastore.connection import Connection
from gcloud.datastore import query

from oauth2client import client

def get_connection():
  client_email = '[email protected]'
  private_key_string = open('/path/to/yourfile.p12', 'rb').read()

  svc_account_credentials = client.SignedJwtAssertionCredentials(
    service_account_name=client_email,
    private_key=private_key_string,
    scope=SCOPE)

  return Connection(credentials=svc_account_credentials)


def connect_to_dataset(dataset_id):
  connection = get_connection()
  datastore.set_default_connection(connection)
  datastore.set_default_dataset_id(dataset_id)

if __name__ == "__main__":
  connect_to_dataset(DATASET_NAME)
  gae_entity_query = query.Query()
  gae_entity_query.keys_only()
  for entity in gae_entity_query.fetch():
    if entity.kind[0] != '_':
      print entity.kind
      entity.key.delete()

• Wenn Sie die Idee von svpino fortsetzen, ist es ratsam, als gelöscht gekennzeichnete Datensätze wiederzuverwenden. (Seine Idee war nicht, nicht verwendete Datensätze zu entfernen, sondern als "gelöscht" zu markieren). Ein wenig Cache / Memcache, um die Arbeitskopie zu verarbeiten und nur unterschiedliche Status (vor und nach der gewünschten Aufgabe) in den Datenspeicher zu schreiben, macht es besser. Für große Aufgaben ist es möglich, mittlere Differenzblöcke in den Datenspeicher zu schreiben, um Datenverlust zu vermeiden, wenn der Memcache verschwindet. Um es verlustsicher zu machen, ist es möglich, die Integrität / Existenz von zwischengespeicherten Ergebnissen zu überprüfen und die Aufgabe (oder den erforderlichen Teil) neu zu starten, um fehlende Berechnungen zu wiederholen. Wenn Datenunterschiede in den Datenspeicher geschrieben werden, werden die erforderlichen Berechnungen in der Warteschlange verworfen.

• Eine andere Idee, die der reduzierten Karte ähnelt, besteht darin, die Entitätsart auf mehrere verschiedene Entitätsarten aufzuteilen, sodass sie zusammen gesammelt und für den Endbenutzer als einzelne Entitätsart sichtbar wird. Einträge werden nur als "gelöscht" markiert. Wenn die Anzahl der "gelöschten" Einträge pro Shard ein bestimmtes Limit überschreitet, werden "lebendige" Einträge auf andere Shards verteilt, und dieser Shard wird für immer geschlossen und dann manuell von der Entwicklungskonsole gelöscht (zu geringeren Kosten raten). Nur Datensatz für Datensatz zum regulären Preis löschen.

• Es ist möglich, große Mengen von Datensätzen durch Abfrage von Chunks zu löschen, ohne dass Gae ausfällt (funktioniert zumindest lokal), und es besteht die Möglichkeit, beim nächsten Versuch fortzufahren, wenn die Zeit abgelaufen ist:

    qdelete.getFetchPlan().setFetchSize(100);

    while (true)
    {
        long result = qdelete.deletePersistentAll(candidates);
        LOG.log(Level.INFO, String.format("deleted: %d", result));
        if (result <= 0)
            break;
    }

• Manchmal ist es auch nützlich, ein zusätzliches Feld in der Primärtabelle zu erstellen, anstatt Kandidaten (zugehörige Datensätze) in eine separate Tabelle aufzunehmen. und ja, das Feld kann ein nicht indiziertes / serialisiertes Array mit geringen Berechnungskosten sein.

Für alle Personen, die eine schnelle Lösung für den Entwicklungsserver benötigen (zum Zeitpunkt des Schreibens im Februar 2016):

1. Stoppen Sie den Entwicklungsserver.
2. Löschen Sie das Zielverzeichnis .
3. Erstellen Sie das Projekt neu.

Dadurch werden alle Daten aus dem Datenspeicher gelöscht.

Ich war so frustriert über vorhandene Lösungen zum Löschen aller Daten im Live-Datenspeicher, dass ich eine kleine GAE-App erstellt habe, mit der innerhalb von 30 Sekunden eine ganze Menge Daten gelöscht werden können.

So installieren Sie usw .: https://github.com/xamde/xydra

Für Java

DatastoreService db = DatastoreServiceFactory.getDatastoreService();
List<Key> keys = new ArrayList<Key>();
for(Entity e : db.prepare(new Query().setKeysOnly()).asIterable())
    keys.add(e.getKey());
db.delete(keys);

Funktioniert gut in Development Server

Sie haben zwei einfache Möglichkeiten:

# 1: Um Kosten zu sparen, löschen Sie das gesamte Projekt

# 2: Verwenden von ts-datastore-orm:

https://www.npmjs.com/package/ts-datastore-orm warten auf Entity.truncate (); Durch das Abschneiden können ca. 1 KB Zeilen pro Sekunde gelöscht werden