TL; DR: Come posso esportare un set di coppie chiave / valore da un file di testo nell'ambiente shell?

Per la cronaca, di seguito è riportata la versione originale della domanda, con esempi.

Sto scrivendo uno script in bash che analizza i file con 3 variabili in una determinata cartella, questa è una di queste:

MINIENTREGA_FECHALIMITE="2011-03-31"
MINIENTREGA_FICHEROS="informe.txt programa.c"
MINIENTREGA_DESTINO="./destino/entrega-prac1"

Questo file è archiviato in ./conf/prac1

Il mio script minientrega.sh quindi analizza il file utilizzando questo codice:

cat ./conf/$1 | while read line; do
    export $line
done

Ma quando eseguo minientrega.sh prac1dalla riga di comando non imposta le variabili di ambiente

Ho anche provato a utilizzare source ./conf/$1ma lo stesso problema si applica ancora

Forse c'è un altro modo per farlo, ho solo bisogno di usare le variabili d'ambiente del file che passo come argomento del mio script.

Problema con il vostro approccio è l' exportnel whileciclo sta accadendo in un guscio di sub, e quelli variabile non sarà disponibile in shell corrente (shell genitore del ciclo while).

Aggiungi il exportcomando nel file stesso:

export MINIENTREGA_FECHALIMITE="2011-03-31"
export MINIENTREGA_FICHEROS="informe.txt programa.c"
export MINIENTREGA_DESTINO="./destino/entrega-prac1"

Quindi è necessario originare il file nella shell corrente usando:

. ./conf/prac1

O

source ./conf/prac1

Questo potrebbe essere utile:

export $(cat .env | xargs) && rails c

Il motivo per cui lo uso è se voglio testare .envcose nella mia console di binari.

gabrielf ha trovato un buon modo per mantenere le variabili locali. Questo risolve il potenziale problema quando si passa da un progetto all'altro.

env $(cat .env | xargs) rails

Ho provato questo con bash 3.2.51(1)-release

Aggiornare:

Per ignorare le righe che iniziano con #, usa questo (grazie al commento di Pete ):

export $(grep -v '^#' .env | xargs)

E se vuoi unsettutte le variabili definite nel file, usa questo:

unset $(grep -v '^#' .env | sed -E 's/(.*)=.*/\1/' | xargs)

Aggiornare:

Per gestire anche i valori con spazi, utilizzare:

export $(grep -v '^#' .env | xargs -d '\n')

su sistemi GNU - oppure:

export $(grep -v '^#' .env | xargs -0)

su sistemi BSD.

-o allexportconsente di esportare tutte le seguenti definizioni delle variabili. +o allexportdisabilita questa funzione.

set -o allexport
source conf-file
set +o allexport

set -a
. ./env.txt
set +a

Se env.txtè come:

VAR1=1
VAR2=2
VAR3=3
...

Spiegazioni -a equivale a allexport . In altre parole, ogni assegnazione di variabili nella shell viene esportata nell'ambiente (per essere utilizzata da più processi figlio). Ulteriori informazioni sono disponibili nella documentazione integrata di Set :

-a A     ogni variabile o funzione creata o modificata viene assegnato l'attributo export e contrassegnato per l'esportazione nell'ambiente di comandi successivi.

L'uso di "+" anziché di "-" comporta la disattivazione di queste opzioni. Le opzioni possono anche essere utilizzate su invocazione della shell. L'attuale set di opzioni può essere trovato in $ -.

L' allexportopzione è menzionata in un paio di altre risposte qui, per cui set -aè il collegamento. Sourcing di .env è davvero meglio che passare in rassegna le righe e esportare perché consente commenti, righe vuote e persino variabili d'ambiente generate dai comandi. Il mio .bashrc include quanto segue:

# .env loading in the shell
dotenv () {
  set -a
  [ -f .env ] && . .env
  set +a
}

# Run dotenv on login
dotenv

# Run dotenv on every new directory
cd () {
  builtin cd $@
  dotenv
}

eval $(cat .env | sed 's/^/export /')

Ho trovato il modo più efficiente è:

export $(xargs < .env)

Spiegazione

Quando abbiamo un .envfile come questo:

key=val
foo=bar

la corsa xargs < .envavràkey=val foo=bar

quindi avremo un export key=val foo=bar ed è esattamente ciò di cui abbiamo bisogno!

Limitazione

1. Non gestisce i casi in cui i valori contengono spazi. Comandi come env producono questo formato. - @Shardj

Ecco un'altra sedsoluzione, che non esegue eval o richiede ruby:

source <(sed -E -n 's/[^#]+/export &/ p' ~/.env)

Ciò aggiunge l'esportazione, mantenendo i commenti sulle righe che iniziano con un commento.

Contenuti .env

A=1
#B=2

esecuzione del campione

$ sed -E -n 's/[^#]+/export &/ p' ~/.env
export A=1
#export B=2

Ho trovato questo particolarmente utile quando si costruisce un file simile per il caricamento in un file di unità di sistema, conEnvironmentFile .

Ho votato a favore della risposta di user4040650 perché è sia semplice che consente commenti nel file (ovvero righe che iniziano con #), il che è altamente desiderabile per me, poiché è possibile aggiungere commenti che spiegano le variabili. Basta riscrivere nel contesto della domanda originale.

Se lo script è chiamato come indicato minientrega.sh prac1:, quindi minientrega.sh potrebbe avere:

set -a # export all variables created next
source $1
set +a # stop exporting

# test that it works
echo "Ficheros: $MINIENTREGA_FICHEROS"

Quanto segue è stato estratto dalla documentazione impostata :

Questo built-in è così complicato che merita una sua sezione. set consente di modificare i valori delle opzioni della shell e impostare i parametri posizionali o di visualizzare i nomi e i valori delle variabili della shell.

set [--abefhkmnptuvxBCEHPT] [-o nome-opzione] [argomento ...] set [+ abefhkmnptuvxBCEHPT] [+ o nome-opzione] [argomento ...]

Se non vengono fornite opzioni o argomenti, set visualizza i nomi e i valori di tutte le variabili e funzioni della shell, ordinate in base alla locale corrente, in un formato che può essere riutilizzato come input per l'impostazione o il ripristino delle variabili attualmente impostate. Le variabili di sola lettura non possono essere ripristinate. In modalità POSIX, sono elencate solo le variabili shell.

Quando vengono fornite le opzioni, impostano o annullano gli attributi della shell. Le opzioni, se specificate, hanno i seguenti significati:

-a A ogni variabile o funzione creata o modificata viene assegnato l'attributo export e contrassegnato per l'esportazione nell'ambiente di comandi successivi.

E anche questo:

L'uso di "+" anziché di "-" comporta la disattivazione di queste opzioni. Le opzioni possono anche essere utilizzate su invocazione della shell. L'attuale set di opzioni può essere trovato in $ -.

Migliorare la risposta di Silas Paul

l'esportazione delle variabili su una subshell le rende locali al comando.

(export $(cat .env | xargs) && rails c)

SAVE=$(set +o | grep allexport) && set -o allexport && . .env; eval "$SAVE"

Ciò salverà / ripristinerà le opzioni originali, qualunque esse siano.

L'utilizzo set -o allexportha il vantaggio di saltare correttamente i commenti senza regex.

set +oda solo restituisce tutte le opzioni correnti in un formato che bash potrà successivamente eseguire. Utile anche: set -oda solo, genera tutte le opzioni attuali in un formato a misura d'uomo.

Il modo più breve che ho trovato:

Il tuo .envfile:

VARIABLE_NAME="A_VALUE"

Quindi basta

. ./.env && echo ${VARIABLE_NAME}

Bonus: poiché è un one-liner corto, è molto utile nel package.jsonfile

  "scripts": {
    "echo:variable": ". ./.env && echo ${VARIABLE_NAME}"
  }

Più semplice:

1. prendi il contenuto del file
2. rimuovi le righe vuote (basta che tu abbia separato alcune cose)
3. rimuovi eventuali commenti (nel caso in cui tu ne abbia aggiunto alcuni ...)
4. aggiungere exporta tutte le righe
5. eval l'intera cosa

eval $(cat .env | sed -e /^$/d -e /^#/d -e 's/^/export /')

Un'altra opzione (non è necessario eseguire eval(grazie a @Jaydeep)):

export $(cat .env | sed -e /^$/d -e /^#/d | xargs)

Infine, se vuoi semplificarti davvero la vita, aggiungi questo al tuo ~/.bash_profile:

function source_envfile() { export $(cat $1 | sed -e /^$/d -e /^#/d | xargs); }

(ASSICURARSI DI RICARICARE LE IMPOSTAZIONI DI BASH !!! source ~/.bash_profileo ... basta creare una nuova scheda / finestra e risolvere il problema) la si chiama così:source_envfile .env

È possibile utilizzare lo script originale per impostare le variabili, ma è necessario chiamarlo nel modo seguente (con punto autonomo):

. ./minientrega.sh

Inoltre potrebbe esserci un problema con l' cat | while readapproccio. Consiglierei di usare l'approccio while read line; do .... done < $FILE.

Ecco un esempio funzionante:

> cat test.conf
VARIABLE_TMP1=some_value

> cat run_test.sh
#/bin/bash
while read line; do export "$line";
done < test.conf
echo "done"

> . ./run_test.sh
done

> echo $VARIABLE_TMP1
some_value

Sulla base di altre risposte, ecco un modo per esportare solo un sottoinsieme di righe in un file, inclusi valori con spazi come PREFIX_ONE="a word":

set -a
. <(grep '^[ ]*PREFIX_' conf-file)
set +a

Ecco la mia variante:

  with_env() {
    (set -a && . ./.env && "$@")
  }

rispetto alle soluzioni precedenti:

• non perde le variabili al di fuori dell'ambito (i valori di .envnon sono esposti al chiamante)
• non ostruisce le setopzioni
• restituisce il codice di uscita del comando eseguito
• usa posix compatibile set -a
• usa .invece di sourceevitare il bashismo
• il comando non viene richiamato se il .envcaricamento non riesce

with_env rails console

Lavoro con docker-compose e .envfile su Mac e volevo importare la .envmia shell bash (per i test), e la risposta "migliore" qui è stata la seguente:

.env

NODE_ARGS=--expose-gc --max_old_space_size=2048

Soluzione

Così ho finito per usare evale racchiudere i miei valori env var tra virgolette singole.

eval $(grep -v -e '^#' .env | xargs -I {} echo export \'{}\')

Versione Bash

$ /bin/bash --version
GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin18)
Copyright (C) 2007 Free Software Foundation, Inc.

Il mio .env:

#!/bin/bash
set -a # export all variables

#comments as usual, this is a bash script
USER=foo
PASS=bar

set +a #stop exporting variables

invocare:

source .env; echo $USER; echo $PASS

Riferimento /unix/79068/how-to-export-variables-that-are-set-all-at-once

Ho problemi con le soluzioni suggerite in precedenza:

• La soluzione di @ anubhava rende la scrittura di file di configurazione bash friendly molto fastidiosa molto velocemente, e potresti anche non voler esportare sempre la tua configurazione.
• La soluzione @Silas Paul si interrompe quando si hanno variabili con spazi o altri caratteri che funzionano bene nei valori tra virgolette, ma $()creano un disastro.

Ecco la mia soluzione, che è ancora piuttosto terribile IMO - e non risolve il problema "esporta solo su un figlio" risolto da Silas (anche se probabilmente puoi eseguirlo in una sotto-shell per limitare l'ambito):

source .conf-file
export $(cut -d= -f1 < .conf-file)

Le mie esigenze erano:

• semplice file .env senza exportprefissi (per compatibilità con dotenv)
• valori di supporto tra virgolette: TEXT = "alpha bravo charlie"
• commenti di supporto preceduti da # e righe vuote
• universale per mac / BSD e linux / GNU

Versione di lavoro completa compilata dalle risposte sopra:

  set -o allexport
  eval $(grep -v '^#' .env | sed 's/^/export /')
  set +o allexport

Innanzitutto, crea un file di ambiente che avrà tutta la coppia chiave-valore degli ambienti come di seguito e chiamalo come preferisci nel mio caso env_var.env

MINIENTREGA_FECHALIMITE="2011-03-31"
MINIENTREGA_FICHEROS="informe.txt programa.c"
MINIENTREGA_DESTINO="./destino/entrega-prac1"

Quindi crea uno script che esporterà tutte le variabili di ambiente per l'ambiente Python come di seguito e chiamalo come export_env.sh

#!/usr/bin/env bash

ENV_FILE="$1"
CMD=${@:2}

set -o allexport
source $ENV_FILE
set +o allexport

$CMD

Questo script prenderà il primo argomento come file di ambiente, quindi esporterà tutte le variabili di ambiente in quel file e quindi eseguirà il comando.

USO:

./export_env.sh env_var.env python app.py

Mi sono imbattuto in questo thread quando stavo provando a riutilizzare Docker --env-filein una shell. Il loro formato non è compatibile con bash ma è semplice: name=valuenessuna citazione, nessuna sostituzione. Ignorano anche righe e #commenti vuoti .

Non sono riuscito a renderlo compatibile con posix, ma eccone uno che dovrebbe funzionare con shell tipo bash (testato in zsh su OSX 10.12.5 e bash su Ubuntu 14.04):

while read -r l; do export "$(sed 's/=.*$//' <<<$l)"="$(sed -E 's/^[^=]+=//' <<<$l)"; done < <(grep -E -v '^\s*(#|$)' your-env-file)

Essa non sarà gestire tre casi nell'esempio dalla documentazione collegate di cui sopra:

• bash: export: `123qwe=bar': not a valid identifier
• bash: export: `org.spring.config=something': not a valid identifier
• e non gestirà la sintassi passthrough (una nuda FOO)

Spazi bianchi nel valore

Ci sono molte ottime risposte qui, ma le ho trovate tutte prive di supporto per gli spazi bianchi nel valore:

DATABASE_CLIENT_HOST=host db-name db-user 0.0.0.0/0 md5

Ho trovato 2 soluzioni che funzionano con tali valori con supporto per righe e commenti vuoti.

Uno basato sulla risposta sed e @ javier-buzzi :

source <(sed -e /^$/d -e /^#/d -e 's/.*/declare -x "&"/g' .env)

E uno con la riga di lettura in un ciclo basato sulla risposta @ john1024

while read -r line; do declare -x "$line"; done < <(egrep -v "(^#|^\s|^$)" .env)

La chiave qui sta nell'usare declare -xe mettere la linea tra virgolette. Non so perché, ma quando riformatti il ​​codice del ciclo su più righe non funzionerà - non sono un programmatore bash, ho appena divorato insieme questi, è ancora magico per me :)

prova qualcosa del genere

for line in `cat your_env_file`; do if [[ $line != \#* ]];then export $line; fi;done

t=$(mktemp) && export -p > "$t" && set -a && . ./.env && set +a && . "$t" && rm "$t" && unset t

Come funziona

1. Crea file temporaneo.
2. Scrivi tutti i valori delle variabili di ambiente correnti nel file temporaneo.
3. Abilita l'esportazione di tutte le variabili dichiarate nello script dei sorgenti nell'ambiente.
4. Leggi il .envfile. Tutte le variabili verranno esportate nell'ambiente corrente.
5. Disabilita l'esportazione di tutte le variabili dichiarate nello script dei sorgenti nell'ambiente.
6. Leggi il contenuto del file temporaneo. Ogni riga dovrebbe declare -x VAR="val"esportare ciascuna delle variabili in ambiente.
7. Rimuovi il file temporaneo.
8. Deseleziona il nome del file temporaneo di mantenimento della variabile.

Caratteristiche

• Conserva i valori delle variabili già impostate nell'ambiente
• .env può avere commenti
• .env può avere righe vuote
• .envnon richiede intestazioni o piè di pagina speciali come nelle altre risposte ( set -aeset +a )
• .envnon richiede di avere exportper ogni valore
• one-liner

Se ricevi un errore perché una delle tue variabili contiene un valore che contiene spazi bianchi, puoi provare a ripristinare bash IFS(Internal Field Separator) \nper consentire a bash di interpretare il cat .envrisultato come un elenco di parametri perenv eseguibile.

Esempio:

IFS=$'\n'; env $(cat .env) rails c

Guarda anche:

• http://tldp.org/LDP/abs/html/internalvariables.html#IFSREF
• https://unix.stackexchange.com/a/196761

Il mio file .env è simile a:

DATABASE_URI="postgres://sa:***@localhost:5432/my_db"
VARIABLE_1="SOME_VALUE"
VALIABLE_2="123456788"

Usando i modi di @henke , il valore esportato finisce per contenere le virgolette"

"postgres://sa:***@localhost:5432/my_db"
"SOME_VALUE"
"123456788"

Ma voglio che il valore esportato contenga solo:

postgres://sa:***@localhost:5432/my_db
SOME_VALUE
123456788

Per risolverlo, modifico il comando per eliminare le virgolette:

export $(grep -v '^#' dev.env | tr --delete '"' | xargs -d '\n')

Questo affronta gli spazi sull'RHS e salta i vars "strani" come le definizioni del modulo bash (con "()"):

echo "# source this to set env vars" > $bld_dir/.env
env | while read line; do
    lhs="${line%%=*}"
    rhs="${line#*=}"
    if [[ "$lhs" =~ ^[0-9A-Za-z_]+$ ]]; then
        echo "export $lhs=\"$rhs\"" >> $bld_dir/.env
    fi
done