What Is A Good Place To Store Configuration In Google Appengine (python)

I am making a Google AppEngine application and am doubting were I should store (sensitive) configuration data like credentials. Should I make a single bigtable entity for configur

Solution 1:

If you're okay with embedding them in your source, you can do that, but if you need it to be dynamically configurable, the datastore is the way to go. You can avoid fetching the settings on every request by caching them in local memory. Here's a helper class for that:

classConfiguration(db.Model):
  _INSTANCE = None  @classmethoddefget_instance(cls):
    ifnot cls._INSTANCE:
      cls._INSTANCE = cls.get_or_insert('config')
    return cls._INSTANCE

Simply subclass this with whatever configuration values you need (or modify the class itself). Because loaded code persists between requests, you'll only have to do a single fetch per app instance - though if you want to be able to update the configuration dynamically, you may want to build in a timeout.

If you want to cache stuff for a limited time, your best option is simply storing the timestamp when you fetched it:

classConfiguration(db.Model):
  CACHE_TIME = datetime.timedelta(minutes=5)

  _INSTANCE = None
  _INSTANCE_AGE = None  @classmethoddefget_instance(cls):
    now = datetime.datetime.now()
    ifnot cls._INSTANCE or cls._INSTANCE_AGE + cls.CACHE_TIME < now:
      cls._INSTANCE = cls.get_or_insert('config')
      cls._INSTANCE_AGE = now
    return cls._INSTANCE

Solution 2:

Store them in a module. You can go simple, like having a config.py module with, say:

AMAZON_KEY = 'XXXX'

Then use:

importconfigservice= my_amazon_service(config.AMAZON_KEY)

Or have a slightly more sophisticated config object that allows you to have sensible defaults for your app, namespaced config keys etc.

Solution 3:

If it's sensitive data, you should not store it in source code as it will be checked into source control. The wrong people (inside or outside your organization) may find it there. Also, your development environment probably uses different config values from your production environment. If these values are stored in code, you will have to run different code in development and production, which is messy and bad practice.

In my projects, I put config data in the datastore using this class:

from google.appengine.ext import ndb

class Settings(ndb.Model):
  name = ndb.StringProperty()
  value = ndb.StringProperty()

  @staticmethod
  def get(name):
    NOT_SET_VALUE = "NOT SET"
    retval = Settings.query(Settings.name == name).get()
    ifnot retval:
      retval = Settings()
      retval.name = name
      retval.value = NOT_SET_VALUE
      retval.put()
    if retval.value == NOT_SET_VALUE:
      raise Exception(('Setting %s not found in the database. A placeholder ' +'record has been created. Go to the Developers Console for your app ' +'in App Engine, look up the Settings record with name=%s and enter ' +'its value in that record\'s value field.') % (name, name))return retval.value

Your application would do this to get a value:

AMAZON_KEY = Settings.get('AMAZON_KEY')

If there is a value for that key in the datastore, you will get it. If there isn't, a placeholder record will be created and an exception will be thrown. The exception will remind you to go to the Developers Console and update the placeholder record.

I find this takes the guessing out of setting config values. If you are unsure of what config values to set, just run the code and it will tell you!