Einlesen von Umgebungsvariablen aus einer Umgebungsdatei

Ich möchte in einer lokalen Umgebung ein Python-Skript ausführen, das normalerweise in einem Docker-Container ausgeführt wird. Die docker-compose.yml spezifiziert ein env_file was (teilweise) wie folgt aussieht:

DB_ADDR=rethinkdb
DB_PORT=28015
DB_NAME=ipercron

Um dies lokal auszuführen, möchte ich, dass diese Zeilen konvertiert werden

os.environ['DB_ADDR'] = 'rethinkdb'
os.environ['DB_PORT'] = '28015'
os.environ['DB_NAME'] = 'ipercron'

Ich könnte meinen Parser schreiben, aber ich habe mich gefragt, ob es vorhandene Module/Tools zum Einlesen von Umgebungsvariablen aus Konfigurationsdateien gibt?

ich benutze Python Dotenv-Bibliothek. Installieren Sie einfach die Bibliothek pip install python-dotenvein … kreieren .env Datei mit Ihren Umgebungsvariablen und importieren Sie die Umgebungsvariablen wie folgt in Ihren Code:

import os
from dotenv import load_dotenv

load_dotenv()

MY_ENV_VAR = os.getenv('MY_ENV_VAR')

Von dem .env Datei:

MY_ENV_VAR="This is my env var content."

Auf diese Weise mache ich es, wenn ich Code außerhalb meines Docker-Systems testen und ihn darauf vorbereiten muss, ihn wieder in Docker zurückzugeben.

Wenn Ihr System/Ihre Umgebung/Ihr Arbeitsablauf die Verwendung von Shell-Skripten unterstützt, können Sie ein Skript erstellen, das diese beiden Vorgänge umschließt:

1. Beschaffung der .env-Datei und Export als Umgebungsvariablen
   • Verwendung der set -a Option wo “Jede Variable oder Funktion, die erstellt oder geändert wird, erhält das Exportattribut und wird für den Export in die Umgebung nachfolgender Befehle markiert“.
2. Aufrufen Ihres Python-Skripts / Ihrer Python-App, die plain os.environ.get Code

Beispiel für eine .env-Datei (config.env):

TYPE=prod
PORT=5000

Beispiel-Python-Code (test.py):

import os

print(os.environ.get('TYPE'))
print(os.environ.get('PORT'))

Beispiel-Bash-Skript (run.sh):

#!/usr/bin/env bash

set -a
source config.env
set +a

python3 test.py

Beispiellauf:

$ tree
.
├── config.env
├── run.sh
└── test.py

$ echo $TYPE

$ echo $PORT

$ python3 test.py
None
None

$ ./run.sh 
prod
5000

Wenn Sie das Python-Skript direkt ausführen (python3 test.py) ohne source-ing die .env-Datei, alle environ.get Anrufe zurück None.

Wenn Sie es jedoch in ein Shell-Skript einschließen, das zuerst die .env-Datei in Umgebungsvariablen lädt und anschließend das Python-Skript ausführt, sollte das Python-Skript jetzt in der Lage sein, die Umgebungsvariablen korrekt zu lesen. Es stellt auch sicher, dass die exportierten env-Variablen nur als Teil der Ausführung Ihrer Python-Anwendung/Ihres Python-Skripts existieren.

Im Vergleich zu der anderen beliebten Antwort benötigt dies keine externen Python-Bibliotheken.

Das könnte auch für dich funktionieren:

env_vars = [] # or dict {}
with open(env_file) as f:
    for line in f:
        if line.startswith('#') or not line.strip():
            continue
        # if 'export' not in line:
        #     continue
        # Remove leading `export `, if you have those
        # then, split name / value pair
        # key, value = line.replace('export ', '', 1).strip().split('=', 1)
        key, value = line.strip().split('=', 1)
        # os.environ[key] = value  # Load to local environ
        # env_vars[key] = value # Save to a dict, initialized env_vars = {}
        env_vars.append({'name': key, 'value': value}) # Save to a list

print(env_vars)

In den Kommentaren finden Sie einige verschiedene Möglichkeiten, die env-Variablen zu speichern, und auch einige Parsing-Optionen, dh um die führenden zu entfernen export Stichwort. Eine andere Möglichkeit wäre die Verwendung von python-dotenv Bücherei. Beifall.

UPDATE: Ich habe meine eigene envvar_utils.py eingerichtet, um die Konvertierung von Zeichenfolgen usw.

"""Utility functions for dealing with env variables and reading variables from env file"""
import os
import logging
import json

BOOLEAN_TYPE = 'boolean'
INT_TYPE = 'int'
FLOAT_TYPE = 'float'
STRING_TYPE = 'str'
LIST_TYPE = 'list'
DICT_TYPE = 'dict'


def get_envvars(env_file=".env", set_environ=True, ignore_not_found_error=False, exclude_override=()):
    """
    Set env vars from a file
    :param env_file:
    :param set_environ:
    :param ignore_not_found_error: ignore not found error
    :param exclude_override: if parameter found in this list, don't overwrite environment
    :return: list of tuples, env vars
    """
    env_vars = []
    try:

        with open(env_file) as f:
            for line in f:
                line = line.replace('\n', '')

                if not line or line.startswith('#'):
                    continue

                # Remove leading `export `
                if line.lower().startswith('export '):
                    key, value = line.replace('export ', '', 1).strip().split('=', 1)
                else:
                    try:
                        key, value = line.strip().split('=', 1)
                    except ValueError:
                        logging.error(f"envar_utils.get_envvars error parsing line: '{line}'")
                        raise

                if set_environ and key not in exclude_override:
                    os.environ[key] = value

                if key in exclude_override:
                    env_vars.append({'name': key, 'value': os.getenv(key)})
                else:
                    env_vars.append({'name': key, 'value': value})
    except FileNotFoundError:
        if not ignore_not_found_error:
            raise

    return env_vars


def create_envvar_file(env_file_path, envvars):
    """
    Writes envvar file using env var dict
    :param env_file_path: str, path to file to write to
    :param envvars: dict, env vars
    :return:
    """
    with open(env_file_path, "w+") as f:
        for key, value in envvars.items():
            f.write("{}={}\n".format(key, value))
    return True


def convert_env_var_flag_to(env_var_name, required_type, default_value):
    """
    Convert env variable string flag values to required_type
    :param env_var_name: str, environment variable name
    :param required_type: str, required type to cast the env var to
    :param default_value: boolean, default value to use if the environment variable is not available
    :return: environment variable value in required type
    """
    env_var_orginal_value = os.getenv(env_var_name, default_value)
    env_var_value = ""
    try:
        if required_type == INT_TYPE:
            env_var_value = int(env_var_orginal_value)
        elif required_type == FLOAT_TYPE:
            env_var_value = float(env_var_orginal_value)
        elif required_type == BOOLEAN_TYPE:
            env_var_value = bool(int(env_var_orginal_value))
        elif required_type == STRING_TYPE:
            env_var_value = str(env_var_orginal_value)
        elif required_type == LIST_TYPE:
            env_var_value = env_var_orginal_value.split(',') if len(env_var_orginal_value) > 0 else default_value
        elif required_type == DICT_TYPE:
            try:
                env_var_value = json.loads(env_var_orginal_value) if env_var_orginal_value else default_value
            except Exception as e:
                logging.error(f"convert_env_var_flag_to: failed loading {env_var_orginal_value} error {e}")
                env_var_value = default_value
        else:
            logging.error("Unrecognized type {} for env var {}".format(required_type, env_var_name))

    except ValueError:
        env_var_value = default_value
        logging.warning("{} is {}".format(env_var_name, env_var_orginal_value))

    return env_var_value

Sie können verwenden ConfigParser. Musterbeispiel finden Sie hier.

Aber diese Bibliothek erwartet Ihre key=value Daten unter einigen vorhanden sein [heading]. Zum Beispiel wie:

[mysqld]
user = mysql  # Key with values
pid-file = /var/run/mysqld/mysqld.pid
skip-external-locking
old_passwords = 1
skip-bdb      # Key without value
skip-innodb

Dewald Abrie hat eine gute Lösung gepostet.

Hier ist eine kleine Modifikation, die Bruchkanten ignoriert (\n)

def get_env_data_as_dict(path: str) -> dict:
    with open(path, 'r') as f:
       return dict(tuple(line.replace('\n', '').split('=')) for line
                in f.readlines() if not line.startswith('#'))

print(get_env_data_as_dict('../db.env'))

Wie wäre es damit für eine kompaktere Lösung:

import os

with open('.docker-compose-env', 'r') as fh:
    vars_dict = dict(
        tuple(line.replace('\n', '').split('='))
        for line in fh.readlines() if not line.startswith('#')
    )

print(vars_dict)
os.environ.update(vars_dict)

Verwenden Sie nur Python Std

import re

envre = re.compile(r'''^([^=]+)\s+?=\s+?(?:[\s"']*)(.+?)(?:[\s"']*)$''')
result = {}
with open('/etc/os-release') as ins:
    for line in ins:
        match = envre.match(line)
        if match is not None:
            result[match.group(1)] = match.group(2)