Armazenamento seguro de variáveis ​​de ambiente no GAE com app.yaml

Preciso armazenar chaves de API e outras informações confidenciais app.yamlcomo variáveis ​​de ambiente para implantação no GAE. O problema com isso é que se eu enviar app.yamlpara o GitHub, essa informação se tornará pública (não é boa). Não quero armazenar as informações em um armazenamento de dados, pois não se adequa ao projeto. Em vez disso, gostaria de trocar os valores de um arquivo que está listado em .gitignorecada implantação do aplicativo.

Aqui está meu arquivo 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}

Alguma ideia?

Se forem dados confidenciais, você não deve armazená-los no código-fonte, pois eles serão verificados no controle de origem. As pessoas erradas (dentro ou fora da sua organização) podem encontrá-lo lá. Além disso, seu ambiente de desenvolvimento provavelmente usa valores de configuração diferentes de seu ambiente de produção. Se esses valores forem armazenados no código, você terá que executar códigos diferentes no desenvolvimento e na produção, o que é uma prática confusa e inadequada.

Em meus projetos, coloco dados de configuração no armazenamento de dados usando esta classe:

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

Seu aplicativo faria isso para obter um valor:

API_KEY = Settings.get('API_KEY')

Se houver um valor para essa chave no armazenamento de dados, você o obterá. Se não houver, um registro de espaço reservado será criado e uma exceção será lançada. A exceção o lembrará de ir para o Developers Console e atualizar o registro de espaço reservado.

Acho que isso elimina a suposição de definir valores de configuração. Se você não tiver certeza de quais valores de configuração definir, apenas execute o código e ele lhe dirá!

O código acima usa a biblioteca ndb que usa memcache e o armazenamento de dados por baixo do capô, por isso é rápido.

Atualizar:

jelder perguntou como encontrar os valores do Datastore no console do App Engine e defini-los. Aqui está como:

1. Acesse https://console.cloud.google.com/datastore/

2. Selecione seu projeto no topo da página se ainda não estiver selecionado.

3. Na caixa suspensa Tipo , selecione Configurações .

4. Se você executou o código acima, suas chaves aparecerão. Todos eles terão o valor NOT SET . Clique em cada um e defina seu valor.

Espero que isto ajude!

Esta solução é simples, mas pode não se adequar a todas as equipes diferentes.

Primeiro, coloque as variáveis ​​de ambiente em env_variables.yaml , por exemplo,

env_variables:
  SECRET: 'my_secret'

Então, inclua isso env_variables.yamlnoapp.yaml

includes:
  - env_variables.yaml

Finalmente, adicione o env_variables.yamla .gitignore, de modo que as variáveis ​​secretas não existam no repositório.

Neste caso, o env_variables.yaml precisa ser compartilhado entre os gerenciadores de implementação.

Minha abordagem é armazenar os segredos do cliente apenas no próprio aplicativo do App Engine. Os segredos do cliente não estão no controle de origem nem em nenhum computador local. Isso tem a vantagem de que qualquer colaborador do App Engine pode implantar alterações de código sem ter que se preocupar com os segredos do cliente.

Eu armazeno os segredos do cliente diretamente no Datastore e uso o Memcache para melhorar a latência ao acessar os segredos. As entidades do Datastore precisam ser criadas apenas uma vez e persistirão em implantações futuras. é claro que o console do App Engine pode ser usado para atualizar essas entidades a qualquer momento.

Existem duas opções para executar a criação única da entidade:

• Use o shell interativo da API remota do App Engine para criar as entidades.
• Crie um manipulador somente Admin que inicializará as entidades com valores fictícios. Chame manualmente esse gerenciador de administrador e, em seguida, use o console do App Engine para atualizar as entidades com os segredos do cliente de produção.

A melhor maneira de fazer isso é armazenar as chaves em um arquivo client_secrets.json e excluí-lo do upload para o git, listando-o em seu arquivo .gitignore. Se você tiver chaves diferentes para ambientes diferentes, você pode usar a api app_identity para determinar qual é o id do aplicativo e carregar de forma adequada.

Há um exemplo bastante abrangente aqui -> https://developers.google.com/api-client-library/python/guide/aaa_client_secrets .

Aqui está um exemplo de código:

# 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()

Isso não existia quando você postou, mas para qualquer outra pessoa que tropeçar aqui, o Google agora oferece um serviço chamado Secret Manager .

É um serviço REST simples (com SDKs que o envolvem, é claro) para armazenar seus segredos em um local seguro na plataforma em nuvem do Google. Esta é uma abordagem melhor do que o armazenamento de dados, exigindo etapas extras para ver os segredos armazenados e tendo um modelo de permissão mais refinado - você pode proteger segredos individuais de maneira diferente para diferentes aspectos do seu projeto, se necessário.

Ele oferece controle de versão, para que você possa lidar com alterações de senha com relativa facilidade, bem como uma consulta robusta e camada de gerenciamento que permite descobrir e criar segredos em tempo de execução, se necessário.

SDK Python

Exemplo de uso:

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

Esta solução depende do appcfg.py obsoleto

Você pode usar a opção de linha de comando -E de appcfg.py para configurar as variáveis ​​de ambiente ao implantar seu aplicativo no GAE (atualização 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).
...

A maioria das respostas está desatualizada. Usar o armazenamento de dados em nuvem do Google é um pouco diferente agora. https://cloud.google.com/python/getting-started/using-cloud-datastore

Aqui está um exemplo:

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')

Isso assume que o nome da entidade é 'TWITTER_APP_KEY', o tipo é 'configurações' e 'valor' é uma propriedade da entidade TWITTER_APP_KEY.

Parece que você pode fazer algumas abordagens. Temos um problema semelhante e fazemos o seguinte (adaptado ao seu caso de uso):

• Crie um arquivo que armazene quaisquer valores dinâmicos de app.yaml e coloque-o em um servidor seguro em seu ambiente de construção. Se você for realmente paranóico, pode criptografar os valores de forma assimétrica. Você pode até mesmo mantê-lo em um repositório privado se precisar de controle de versão / pull dinâmico ou apenas usar um script shells para copiá-lo / retirá-lo do local apropriado.
• Puxe do git durante o script de implantação
• Após o git pull, modifique o app.yaml lendo e gravando-o em Python puro usando uma biblioteca yaml

A maneira mais fácil de fazer isso é usar um servidor de integração contínua, como Hudson , Bamboo ou Jenkins . Basta adicionar algum plug-in, etapa de script ou fluxo de trabalho que faça todos os itens acima mencionados. Você pode passar variáveis ​​de ambiente que são configuradas no próprio Bamboo, por exemplo.

Em resumo, basta inserir os valores durante o processo de construção em um ambiente ao qual você só tem acesso. Se você ainda não está automatizando suas compilações, deveria estar.

Outra opção de opção é o que você disse, coloque no banco de dados. Se o motivo para não fazer isso for porque as coisas estão muito lentas, simplesmente envie os valores para o memcache como um cache de segunda camada e fixe os valores nas instâncias como um cache de primeira camada. Se os valores podem mudar e você precisa atualizar as instâncias sem reinicializá-los, apenas mantenha um hash que você pode verificar para saber quando eles mudam ou acioná-lo de alguma forma quando algo que você faz muda os valores. Deve ser isso.

Você deve criptografar as variáveis ​​com google kms e incorporá-las ao seu código-fonte. ( 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 o valor embaralhado (criptografado e codificado em base64) em sua variável de ambiente (no arquivo yaml).

Algum código pythonish para você começar a descriptografar.

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

@Jason F's resposta de base no uso do Google Datastore está próxima, mas o código está um pouco desatualizado com base no uso de amostra nos documentos da biblioteca . Aqui está o snippet que funcionou para mim:

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'])

Parcialmente inspirado por isso postagem do Medium

Só queria observar como resolvi esse problema em javascript / nodejs. Para o desenvolvimento local, usei o pacote npm 'dotenv' que carrega variáveis ​​de ambiente de um arquivo .env em process.env. Quando comecei a usar o GAE, aprendi que as variáveis ​​de ambiente precisam ser definidas em um arquivo 'app.yaml'. Bem, eu não queria usar 'dotenv' para desenvolvimento local e 'app.yaml' para GAE (e duplicar minhas variáveis ​​de ambiente entre os dois arquivos), então escrevi um pequeno script que carrega variáveis ​​de ambiente app.yaml no processo .env, para o desenvolvimento local. Espero que isso ajude alguém:

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]
        })
    }
})()

Agora inclua esse arquivo o mais cedo possível em seu código e pronto:

require('../yaml_env')

Ampliando a resposta 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

Há um pacote pypi chamado gae_env que permite salvar variáveis ​​de ambiente do appengine no Cloud Datastore. Nos bastidores, ele também usa Memcache, então é rápido

Uso:

import gae_env

API_KEY = gae_env.get('API_KEY')

Se houver um valor para essa chave no armazenamento de dados, ele será retornado. Se não houver, um registro de espaço reservado __NOT_SET__será criado e um ValueNotSetErrorserá lançado. A exceção o lembrará de ir para o Developers Console e atualizar o registro de espaço reservado.

Semelhante à resposta de Martin, aqui está como atualizar o valor da chave no Datastore:

1. Acesse a seção Datastore no console de desenvolvedores

2. Selecione seu projeto no topo da página se ainda não estiver selecionado.

3. Na caixa suspensa Tipo , selecione GaeEnvSettings.

4. Chaves para as quais uma exceção foi levantada terão valor __NOT_SET__.

Vá para a página GitHub do pacote para obter mais informações sobre uso / configuração