Almacenamiento seguro de variables de entorno en GAE con app.yaml

Necesito almacenar claves de API y otra información confidencial app.yamlcomo variables de entorno para la implementación en GAE. El problema con esto es que si presiono app.yamla GitHub, esta información se vuelve pública (no es buena). No quiero almacenar la información en un almacén de datos, ya que no se adapta al proyecto. Más bien, me gustaría intercambiar los valores de un archivo que se enumera en .gitignorecada implementación de la aplicación.

Aquí está mi archivo app.yaml:

application: myapp
version: 3 
runtime: python27
api_version: 1
threadsafe: true

libraries:
- name: webapp2
  version: latest
- name: jinja2
  version: latest

handlers:
- url: /static
  static_dir: static

- url: /.*
  script: main.application  
  login: required
  secure: always
# auth_fail_action: unauthorized

env_variables:
  CLIENT_ID: ${CLIENT_ID}
  CLIENT_SECRET: ${CLIENT_SECRET}
  ORG: ${ORG}
  ACCESS_TOKEN: ${ACCESS_TOKEN}
  SESSION_SECRET: ${SESSION_SECRET}

¿Algunas ideas?

Si se trata de datos confidenciales, no debe almacenarlos en el código fuente, ya que se registrarán en el control de fuentes. Las personas equivocadas (dentro o fuera de su organización) pueden encontrarlo allí. Además, su entorno de desarrollo probablemente use valores de configuración diferentes de su entorno de producción. Si estos valores se almacenan en código, tendrá que ejecutar código diferente en desarrollo y producción, lo cual es complicado y una mala práctica.

En mis proyectos, coloco datos de configuración en el almacén de datos usando esta clase:

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()
    if not 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

Su aplicación haría esto para obtener un valor:

API_KEY = Settings.get('API_KEY')

Si hay un valor para esa clave en el almacén de datos, lo obtendrá. Si no lo hay, se creará un registro de marcador de posición y se lanzará una excepción. La excepción le recordará que vaya a Developers Console y actualice el registro de marcador de posición.

Encuentro que esto elimina las conjeturas al establecer los valores de configuración. Si no está seguro de qué valores de configuración establecer, simplemente ejecute el código y se lo dirá.

El código anterior usa la biblioteca ndb que usa memcache y el almacén de datos debajo del capó, por lo que es rápido.

Actualizar:

jelder preguntó cómo encontrar los valores del almacén de datos en la consola de App Engine y configurarlos. Aquí es cómo:

1. Vaya a https://console.cloud.google.com/datastore/

2. Seleccione su proyecto en la parte superior de la página si aún no está seleccionado.

3. En el cuadro desplegable Tipo , seleccione Configuración .

4. Si ejecutó el código anterior, aparecerán sus claves. Todos tendrán el valor NO ESTABLECIDO . Haga clic en cada uno y establezca su valor.

¡Espero que esto ayude!

Esta solución es simple, pero puede que no sea adecuada para todos los equipos.

Primero, coloque las variables de entorno en un env_variables.yaml , por ejemplo,

env_variables:
  SECRET: 'my_secret'

Luego, incluya esto env_variables.yamlen elapp.yaml

includes:
  - env_variables.yaml

Finalmente, agregue el env_variables.yamla .gitignore, para que las variables secretas no existan en el repositorio.

En este caso, las env_variables.yamlnecesidades deben compartirse entre los administradores de implementación.

Mi enfoque es almacenar los secretos del cliente solo dentro de la propia aplicación de App Engine. Los secretos del cliente no están en el control de código fuente ni en ninguna computadora local. Esto tiene la ventaja de que cualquier colaborador de App Engine puede implementar cambios de código sin tener que preocuparse por los secretos del cliente.

Almaceno los secretos del cliente directamente en Datastore y uso Memcache para mejorar la latencia al acceder a los secretos. Las entidades de Datastore solo deben crearse una vez y persistirán en futuras implementaciones. por supuesto, la consola de App Engine se puede utilizar para actualizar estas entidades en cualquier momento.

Hay dos opciones para realizar la creación única de la entidad:

• Usa el shell interactivo de la API remota de App Engine para crear las entidades.
• Cree un controlador de solo administrador que inicializará las entidades con valores ficticios. Invoca manualmente este controlador de administración y, luego, usa la consola de App Engine para actualizar las entidades con los secretos del cliente de producción.

Esto no existía cuando publicaste, pero para cualquier otra persona que se tropiece aquí, Google ahora ofrece un servicio llamado Administrador secreto .

Es un servicio REST simple (con SDK que lo envuelven, por supuesto) para almacenar sus secretos en una ubicación segura en la plataforma en la nube de Google. Este es un enfoque mejor que Data Store, ya que requiere pasos adicionales para ver los secretos almacenados y tiene un modelo de permisos más detallado: puede proteger secretos individuales de manera diferente para diferentes aspectos de su proyecto, si es necesario.

Ofrece control de versiones, por lo que puede manejar los cambios de contraseña con relativa facilidad, así como una capa sólida de consulta y administración que le permite descubrir y crear secretos en tiempo de ejecución, si es necesario.

SDK de Python

Uso de ejemplo:

from google.cloud import secretmanager_v1beta1 as secretmanager

secret_id = 'my_secret_key'
project_id = 'my_project'
version = 1    # use the management tools to determine version at runtime

client = secretmanager.SecretManagerServiceClient()

secret_path = client.secret_verion_path(project_id, secret_id, version)
response = client.access_secret_version(secret_path)
password_string = response.payload.data.decode('UTF-8')

# use password_string -- set up database connection, call third party service, whatever

La mejor manera de hacerlo es almacenar las claves en un archivo client_secrets.json y excluir que se carguen en git al incluirlas en su archivo .gitignore. Si tiene diferentes claves para diferentes entornos, puede usar app_identity api para determinar cuál es la identificación de la aplicación y cargarla de manera adecuada.

Hay un ejemplo bastante completo aquí:> https://developers.google.com/api-client-library/python/guide/aaa_client_secrets .

Aquí hay un código de ejemplo:

# declare your app ids as globals ...
APPID_LIVE = 'awesomeapp'
APPID_DEV = 'awesomeapp-dev'
APPID_PILOT = 'awesomeapp-pilot'

# create a dictionary mapping the app_ids to the filepaths ...
client_secrets_map = {APPID_LIVE:'client_secrets_live.json',
                      APPID_DEV:'client_secrets_dev.json',
                      APPID_PILOT:'client_secrets_pilot.json'}

# get the filename based on the current app_id ...
client_secrets_filename = client_secrets_map.get(
    app_identity.get_application_id(),
    APPID_DEV # fall back to dev
    )

# use the filename to construct the flow ...
flow = flow_from_clientsecrets(filename=client_secrets_filename,
                               scope=scope,
                               redirect_uri=redirect_uri)

# or, you could load up the json file manually if you need more control ...
f = open(client_secrets_filename, 'r')
client_secrets = json.loads(f.read())
f.close()

Esta solución se basa en el obsoleto appcfg.py

Puede usar la opción de línea de comando -E de appcfg.py para configurar las variables de entorno cuando implemente su aplicación en GAE (actualización de appcfg.py)

$ appcfg.py
...
-E NAME:VALUE, --env_variable=NAME:VALUE
                    Set an environment variable, potentially overriding an
                    env_variable value from app.yaml file (flag may be
                    repeated to set multiple variables).
...

La mayoría de las respuestas están desactualizadas. El uso del almacén de datos en la nube de Google es un poco diferente en este momento. https://cloud.google.com/python/getting-started/using-cloud-datastore

He aquí un ejemplo:

from google.cloud import datastore
client = datastore.Client()
datastore_entity = client.get(client.key('settings', 'TWITTER_APP_KEY'))
connection_string_prod = datastore_entity.get('value')

Esto supone que el nombre de la entidad es 'TWITTER_APP_KEY', el tipo es 'configuración' y 'valor' es una propiedad de la entidad TWITTER_APP_KEY.

Parece que puedes hacer algunos enfoques. Tenemos un problema similar y hacemos lo siguiente (adaptado a su caso de uso):

• Cree un archivo que almacene los valores dinámicos de app.yaml y colóquelo en un servidor seguro en su entorno de compilación. Si está realmente paranoico, puede cifrar asimétricamente los valores. Incluso puede mantener esto en un repositorio privado si necesita control de versión / extracción dinámica, o simplemente use un script de shells para copiarlo / extraerlo del lugar apropiado.
• Extraiga de git durante el script de implementación
• Después del git pull, modifique app.yaml leyéndolo y escribiéndolo en python puro usando una biblioteca yaml

La forma más sencilla de hacerlo es utilizar un servidor de integración continua como Hudson , Bamboo o Jenkins . Simplemente agregue algún complemento, paso de guión o flujo de trabajo que realice todos los elementos anteriores que mencioné. Puede pasar variables de entorno que están configuradas en el propio Bamboo, por ejemplo.

En resumen, simplemente introduzca los valores durante su proceso de compilación en un entorno al que solo tiene acceso. Si aún no está automatizando sus compilaciones, debería hacerlo.

Otra opción es lo que dijiste, ponlo en la base de datos. Si su razón para no hacerlo es que las cosas son demasiado lentas, simplemente inserte los valores en Memcache como una caché de segunda capa y fije los valores a las instancias como una caché de primera capa. Si los valores pueden cambiar y necesita actualizar las instancias sin reiniciarlas, simplemente mantenga un hash que pueda verificar para saber cuándo cambian o activarlo de alguna manera cuando algo que haga cambie los valores. Eso debería ser todo.

Debe cifrar las variables con google kms e incrustarlo en su código fuente. ( https://cloud.google.com/kms/ )

echo -n the-twitter-app-key | gcloud kms encrypt \
> --project my-project \
> --location us-central1 \
> --keyring THEKEYRING \
> --key THECRYPTOKEY \
> --plaintext-file - \
> --ciphertext-file - \
> | base64

coloque el valor codificado (cifrado y codificado en base64) en su variable de entorno (en el archivo yaml).

Algún código pythonish para comenzar a descifrar.

kms_client = kms_v1.KeyManagementServiceClient()
name = kms_client.crypto_key_path_path("project", "global", "THEKEYRING", "THECRYPTOKEY")

twitter_app_key = kms_client.decrypt(name, base64.b64decode(os.environ.get("TWITTER_APP_KEY"))).plaintext

La respuesta de @Jason F basada en el uso de Google Datastore es cercana, pero el código está un poco desactualizado según el uso de muestra en los documentos de la biblioteca . Aquí está el fragmento que funcionó para mí:

from google.cloud import datastore

client = datastore.Client('<your project id>')
key = client.key('<kind e.g settings>', '<entity name>') # note: entity name not property
# get by key for this entity
result = client.get(key)
print(result) # prints all the properties ( a dict). index a specific value like result['MY_SECRET_KEY'])

Inspirado en parte por esta publicación de Medium

Solo quería notar cómo resolví este problema en javascript / nodejs. Para el desarrollo local, utilicé el paquete npm 'dotenv' que carga variables de entorno desde un archivo .env a process.env. Cuando comencé a usar GAE, aprendí que las variables de entorno deben configurarse en un archivo 'app.yaml'. Bueno, no quería usar 'dotenv' para el desarrollo local y 'app.yaml' para GAE (y duplicar mis variables de entorno entre los dos archivos), así que escribí un pequeño script que carga las variables de entorno app.yaml en el proceso .env, para el desarrollo local. Espero que esto ayude a alguien:

yaml_env.js:

(function () {
    const yaml = require('js-yaml');
    const fs = require('fs');
    const isObject = require('lodash.isobject')

    var doc = yaml.safeLoad(
        fs.readFileSync('app.yaml', 'utf8'), 
        { json: true }
    );

    // The .env file will take precedence over the settings the app.yaml file
    // which allows me to override stuff in app.yaml (the database connection string (DATABASE_URL), for example)
    // This is optional of course. If you don't use dotenv then remove this line:
    require('dotenv/config');

    if(isObject(doc) && isObject(doc.env_variables)) {
        Object.keys(doc.env_variables).forEach(function (key) {
            // Dont set environment with the yaml file value if it's already set
            process.env[key] = process.env[key] || doc.env_variables[key]
        })
    }
})()

Ahora incluya este archivo lo antes posible en su código y listo:

require('../yaml_env')

Ampliando la respuesta de Martin

from google.appengine.ext import ndb

class Settings(ndb.Model):
    """
    Get sensitive data setting from DataStore.

    key:String -> value:String
    key:String -> Exception

    Thanks to: Martin Omander @ Stackoverflow
    https://stackoverflow.com/a/35261091/1463812
    """
    name = ndb.StringProperty()
    value = ndb.StringProperty()

    @staticmethod
    def get(name):
        retval = Settings.query(Settings.name == name).get()
        if not retval:
            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

    @staticmethod
    def set(name, value):
        exists = Settings.query(Settings.name == name).get()
        if not exists:
            s = Settings(name=name, value=value)
            s.put()
        else:
            exists.value = value
            exists.put()

        return True

Existe un paquete de pypi llamado gae_env que te permite guardar las variables de entorno de appengine en Cloud Datastore. Debajo del capó, también usa Memcache, por lo que es rápido

Uso:

import gae_env

API_KEY = gae_env.get('API_KEY')

Si hay un valor para esa clave en el almacén de datos, se devolverá. Si no lo hay, se __NOT_SET__creará un registro de marcador de posición y se ValueNotSetErrorlanzará un . La excepción le recordará que vaya a Developers Console y actualice el registro de marcador de posición.

Similar a la respuesta de Martin, aquí se explica cómo actualizar el valor de la clave en Datastore:

1. Vaya a la sección Datastore en la consola de desarrolladores

2. Seleccione su proyecto en la parte superior de la página si aún no está seleccionado.

3. En el cuadro desplegable Tipo , seleccione GaeEnvSettings.

4. Las claves para las que se generó una excepción tendrán valor __NOT_SET__.

Vaya a la página de GitHub del paquete para obtener más información sobre el uso / configuración