TL; DR: Comment exporter un ensemble de paires clé / valeur d'un fichier texte dans l'environnement shell?

Pour mémoire, voici la version originale de la question, avec des exemples.

J'écris un script en bash qui analyse des fichiers avec 3 variables dans un certain dossier, c'est l'un d'entre eux:

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

Ce fichier est stocké dans ./conf/prac1

Mon script minientrega.sh analyse ensuite le fichier en utilisant ce code:

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

Mais quand j'exécute minientrega.sh prac1dans la ligne de commande, cela ne définit pas les variables d'environnement

J'ai également essayé d'utiliser source ./conf/$1mais le même problème s'applique toujours

Peut-être qu'il y a une autre façon de le faire, j'ai juste besoin d'utiliser les variables d'environnement du fichier que je passe comme argument de mon script.

Le problème avec votre approche est que exportla whileboucle se produit dans un sous-shell, et ces variables ne seront pas disponibles dans le shell actuel (shell parent de la boucle while).

Ajouter une exportcommande dans le fichier lui-même:

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

Ensuite, vous devez source dans le fichier dans le shell actuel en utilisant:

. ./conf/prac1

OU

source ./conf/prac1

Cela pourrait être utile:

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

La raison pour laquelle j'utilise ceci est si je veux tester des .envtrucs dans ma console de rails.

gabrielf a trouvé un bon moyen de garder les variables locales. Cela résout le problème potentiel lors du passage d'un projet à l'autre.

env $(cat .env | xargs) rails

Je l'ai testé avec bash 3.2.51(1)-release

Mise à jour:

Pour ignorer les lignes commençant par #, utilisez ceci (grâce au commentaire de Pete ):

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

Et si vous voulez unsettoutes les variables définies dans le fichier, utilisez ceci:

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

Mise à jour:

Pour gérer également des valeurs avec des espaces, utilisez:

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

sur les systèmes GNU - ou:

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

sur les systèmes BSD.

-o allexportpermet d'exporter toutes les définitions de variables suivantes. +o allexportdésactive cette fonction.

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

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

Si env.txtc'est comme:

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

Explications -a est équivalent à allexport . En d'autres termes, chaque affectation de variable dans le shell est exportée dans l'environnement (pour être utilisée par plusieurs processus enfants). Plus d'informations peuvent être trouvées dans la documentation intégrée de Set :

-a     Chaque variable ou fonction créée ou modifiée reçoit l'attribut d'exportation et est marquée pour l'exportation vers l'environnement des commandes suivantes.

L'utilisation de «+» plutôt que de «-» entraîne la désactivation de ces options. Les options peuvent également être utilisées lors de l'appel du shell. L'ensemble d'options actuel se trouve dans $ -.

L' allexportoption est mentionnée dans quelques autres réponses ici, dont set -ale raccourci. L'acquisition du .env est vraiment meilleure que la boucle sur les lignes et l'exportation, car elle permet les commentaires, les lignes vides et même les variables d'environnement générées par les commandes. Mon .bashrc comprend les éléments suivants:

# .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 /')

J'ai trouvé que le moyen le plus efficace est:

export $(xargs < .env)

Explication

Lorsque nous avons un .envfichier comme celui-ci:

key=val
foo=bar

courir xargs < .envobtiendrakey=val foo=bar

nous allons donc obtenir un export key=val foo=baret c'est exactement ce dont nous avons besoin!

Limitation

1. Il ne gère pas les cas où les valeurs contiennent des espaces. Des commandes telles que env produisent ce format. - @Shardj

Voici une autre sedsolution, qui n'exécute pas eval ou ne nécessite pas de rubis:

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

Cela ajoute l'exportation, en gardant les commentaires sur les lignes commençant par un commentaire.

Contenu .env

A=1
#B=2

échantillon

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

J'ai trouvé cela particulièrement utile lors de la construction d'un tel fichier pour le chargement dans un fichier d'unité systemd, avecEnvironmentFile .

J'ai surévalué la réponse de user4040650 car elle est à la fois simple et permet les commentaires dans le fichier (c'est-à-dire les lignes commençant par #), ce qui est très souhaitable pour moi, car des commentaires expliquant les variables peuvent être ajoutés. Réécriture dans le contexte de la question d'origine.

Si le script est appelé comme indiqué minientrega.sh prac1:, alors minientrega.sh pourrait avoir:

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

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

Ce qui suit a été extrait de la documentation de l' ensemble :

Cette fonction intégrée est si compliquée qu'elle mérite sa propre section. set vous permet de modifier les valeurs des options du shell et de définir les paramètres de position, ou d'afficher les noms et les valeurs des variables du shell.

set [--abefhkmnptuvxBCEHPT] [-o option-name] [argument…] set [+ abefhkmnptuvxBCEHPT] [+ o option-name] [argument…]

Si aucune option ou argument n'est fourni, set affiche les noms et les valeurs de toutes les variables et fonctions du shell, triés en fonction des paramètres régionaux actuels, dans un format qui peut être réutilisé comme entrée pour définir ou réinitialiser les variables actuellement définies. Les variables en lecture seule ne peuvent pas être réinitialisées. En mode POSIX, seules les variables shell sont répertoriées.

Lorsque des options sont fournies, elles définissent ou désactivent les attributs du shell. Les options, si elles sont spécifiées, ont les significations suivantes:

-a Chaque variable ou fonction créée ou modifiée reçoit l'attribut d'exportation et est marquée pour l'exportation vers l'environnement des commandes suivantes.

Et cela aussi:

L'utilisation de «+» plutôt que de «-» entraîne la désactivation de ces options. Les options peuvent également être utilisées lors de l'appel du shell. L'ensemble d'options actuel se trouve dans $ -.

Améliorer la réponse de Silas Paul

l'exportation des variables sur un sous-shell les rend locales à la commande.

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

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

Cela permettra de sauvegarder / restaurer vos options d'origine, quelles qu'elles soient.

L'utilisation set -o allexporta l'avantage de sauter correctement les commentaires sans regex.

set +oen lui-même génère toutes vos options actuelles dans un format que bash pourra exécuter ultérieurement. Aussi pratique: set -oen lui-même, génère toutes vos options actuelles dans un format convivial.

Le moyen le plus court que j'ai trouvé:

Votre .envdossier:

VARIABLE_NAME="A_VALUE"

Alors juste

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

Bonus: Parce que c'est un court liner, il est très utile dans le package.jsonfichier

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

Plus simple:

1. récupérer le contenu du fichier
2. supprimez toutes les lignes vides (au cas où vous sépareriez des éléments)
3. supprimer les commentaires (au cas où vous en auriez ajouté ...)
4. ajouter exportà toutes les lignes
5. eval le tout

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

Une autre option (vous n'avez pas à exécuter eval(grâce à @Jaydeep)):

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

Enfin, si vous voulez vraiment vous faciliter la vie, ajoutez ceci à votre ~/.bash_profile:

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

(ASSUREZ-VOUS DE RECHARGER VOS PARAMÈTRES DE BASH !!! source ~/.bash_profileou .. faites simplement un nouvel onglet / fenêtre et le problème est résolu) vous l'appelez comme ceci:source_envfile .env

Vous pouvez utiliser votre script d'origine pour définir les variables, mais vous devez l'appeler de la manière suivante (avec un point autonome):

. ./minientrega.sh

Il pourrait également y avoir un problème avec l' cat | while readapproche. Je recommanderais d'utiliser l'approche while read line; do .... done < $FILE.

Voici un exemple de travail:

> 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

En s'appuyant sur d'autres réponses, voici un moyen d'exporter uniquement un sous-ensemble de lignes dans un fichier, y compris des valeurs avec des espaces comme PREFIX_ONE="a word":

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

Voici ma variante:

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

par rapport aux solutions précédentes:

• il ne fuit pas les variables hors de la portée (les valeurs de .envne sont pas exposées à l'appelant)
• n'encombre pas les setoptions
• retourne le code de sortie de la commande exécutée
• utilise la compatibilité posix set -a
• utilise .au lieu d' sourceéviter le bashisme
• la commande n'est pas invoquée si le .envchargement échoue

with_env rails console

Je travaille avec docker-compose et des .envfichiers sur Mac, et .envje voulais importer le dans mon shell bash (pour les tests), et la "meilleure" réponse ici était de trébucher sur la variable suivante:

.env

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

Solution

J'ai donc fini par utiliser evalet encapsuler mes définitions de var env dans des guillemets simples.

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

Version bash

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

Mon .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

Invoquant:

source .env; echo $USER; echo $PASS

Référence /unix/79068/how-to-export-variables-that-are-set-all-at-once

J'ai des problèmes avec les solutions suggérées précédemment:

• La solution de @ anubhava rend l'écriture de fichiers de configuration conviviale très ennuyeuse très rapidement, et aussi - vous ne voudrez peut-être pas toujours exporter votre configuration.
• La solution @Silas Paul se casse lorsque vous avez des variables qui ont des espaces ou d'autres caractères qui fonctionnent bien dans les valeurs entre guillemets, mais $()qui gâchent tout.

Voici ma solution, qui est encore assez terrible IMO - et ne résout pas le problème "exporter seulement vers un enfant" résolu par Silas (bien que vous puissiez probablement l'exécuter dans un sous-shell pour limiter la portée):

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

Mes exigences étaient:

• fichier .env simple sans exportpréfixe (pour compatibilité avec dotenv)
• valeurs de support entre guillemets: TEXT = "alpha bravo charlie"
• prise en charge des commentaires précédés de # et de lignes vides
• universel pour mac / BSD et linux / GNU

Version de travail complète compilée à partir des réponses ci-dessus:

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

Tout d'abord, créez un fichier d'environnement qui aura toute la paire clé-valeur des environnements comme ci-dessous et nommez-le comme vous voulez dans mon cas, son env_var.env

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

Ensuite, créez un script qui exportera toutes les variables d'environnement pour l'environnement python comme ci-dessous et nommez-le comme export_env.sh

#!/usr/bin/env bash

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

set -o allexport
source $ENV_FILE
set +o allexport

$CMD

Ce script prendra le premier argument comme fichier d'environnement, puis exportera toutes les variables d'environnement dans ce fichier et exécutera ensuite la commande.

USAGE:

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

Je suis tombé sur ce fil lorsque j'essayais de réutiliser Docker --env-filedans un shell. Leur format n'est pas compatible bash mais il est simple: name=valuepas de guillemets, pas de substitution. Ils ignorent également les lignes vides et les #commentaires.

Je ne pouvais pas vraiment le rendre compatible posix, mais en voici un qui devrait fonctionner dans des shells de type bash (testé en zsh sur OSX 10.12.5 et bash sur Ubuntu 14.04):

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

Il ne traitera pas trois cas dans l'exemple des documents liés ci-dessus:

• bash: export: `123qwe=bar': not a valid identifier
• bash: export: `org.spring.config=something': not a valid identifier
• et il ne gérera pas la syntaxe passthrough (un nu FOO)

Espaces blancs dans la valeur

Il y a beaucoup de bonnes réponses ici, mais je les ai toutes trouvées manquant de support pour l'espace blanc dans la valeur:

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

J'ai trouvé 2 solutions qui fonctionnent avec de telles valeurs avec le support des lignes vides et des commentaires.

Une réponse basée sur sed et @ javier-buzzi :

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

Et une avec une ligne de lecture dans une boucle basée sur la réponse @ john1024

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

La clé ici est d'utiliser declare -xet de mettre la ligne entre guillemets. Je ne sais pas pourquoi, mais lorsque vous reformatez le code de la boucle sur plusieurs lignes, cela ne fonctionnera pas - je ne suis pas un programmeur bash, je les ai simplement engloutis, c'est toujours magique pour moi :)

essayez quelque chose comme ça

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

Comment ça fonctionne

1. Créez un fichier temporaire.
2. Écrivez toutes les valeurs actuelles des variables d'environnement dans le fichier temporaire.
3. Activez l'exportation de toutes les variables déclarées du script sources vers l'environnement.
4. Lire le .envfichier. Toutes les variables seront exportées dans l'environnement actuel.
5. Désactivez l'exportation de toutes les variables déclarées du script sources vers l'environnement.
6. Lisez le contenu du fichier temporaire. Chaque ligne aurait declare -x VAR="val"qui exporterait chacune des variables dans l'environnement.
7. Supprimez le fichier temporaire.
8. Désactivez la variable contenant le nom du fichier temporaire.

Caractéristiques

• Préserve les valeurs des variables déjà définies dans l'environnement
• .env peut avoir des commentaires
• .env peut avoir des lignes vides
• .envne nécessite pas d'en-tête ou de pied de page spécial comme dans les autres réponses ( set -aet set +a)
• .envne nécessite pas d'avoir exportpour chaque valeur
• bon mot

Si vous obtenez une erreur car l'une de vos variables contient une valeur qui contient des espaces blancs, vous pouvez essayer de réinitialiser bash IFS(séparateur de champ interne) \npour laisser bash interpréter le cat .envrésultat comme une liste de paramètres pour l' envexécutable.

Exemple:

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

Voir également:

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

Mon fichier .env ressemble à:

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

En utilisant les méthodes de @henke , la valeur exportée finit par contenir les guillemets"

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

Mais je veux que la valeur exportée ne contienne que:

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

Pour y remédier, je modifie la commande pour supprimer les guillemets:

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

Celui-ci fait face aux espaces sur le RHS et saute les variables `` étranges '' telles que les définitions de module bash (avec `` () ''):

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