Bash 模板：如何使用 Bash 从模板构建配置文件？

试试 envbust

试试envsubst

$ cat envsubst-template.txt
Variable FOO is (${FOO}).
Variable BAR is (${BAR}).

$ FOO=myfoo

$ BAR=mybar

$ export FOO BAR

$ cat envsubst-template.txt | envsubst
Variable FOO is (myfoo).
Variable BAR is (mybar).

heredoc 是模板化 conf 文件的内置方式。

STATUS_URI="/hows-it-goin";  MONITOR_IP="10.10.2.15";

cat >/etc/apache2/conf.d/mod_status.conf <<EOF
<Location ${STATUS_URI}>
    SetHandler server-status
    Order deny,allow
    Deny from all
    Allow from ${MONITOR_IP}
</Location>
EOF

关于 yottsa's answer：envsubst 对我来说是新的。极好的。

你可以使用这个：

perl -p -i -e 's/\$\{([^}]+)\}/defined $ENV{$1} ? $ENV{$1} : $&/eg' < template.txt

用相应的环境变量替换所有 ${...} 字符串（不要忘记在运行此脚本之前导出它们）。

对于纯 bash 这应该有效（假设变量不包含 ${...} 字符串）：

#!/bin/bash
while read -r line ; do
    while [[ "$line" =~ (\$\{[a-zA-Z_][a-zA-Z_0-9]*\}) ]] ; do
        LHS=${BASH_REMATCH[1]}
        RHS="$(eval echo "\"$LHS\"")"
        line=${line//$LHS/$RHS}
    done
    echo "$line"
done

.如果 RHS 引用了一些引用自身的变量，则不会挂起的解决方案：

#!/bin/bash
line="$(cat; echo -n a)"
end_offset=${#line}
while [[ "${line:0:$end_offset}" =~ (.*)(\$\{([a-zA-Z_][a-zA-Z_0-9]*)\})(.*) ]] ; do
    PRE="${BASH_REMATCH[1]}"
    POST="${BASH_REMATCH[4]}${line:$end_offset:${#line}}"
    VARNAME="${BASH_REMATCH[3]}"
    eval 'VARVAL="$'$VARNAME'"'
    line="$PRE$VARVAL$POST"
    end_offset=${#PRE}
done
echo -n "${line:0:-1}"

警告：我不知道如何正确处理 bash 中的 NUL 输入或保留尾随换行符的数量。最后一个变体按原样呈现，因为 shell “喜欢”二进制输入：

read 将解释反斜杠。 read -r 不会解释反斜杠，但如果最后一行不以换行符结尾，它仍然会删除。 "$(...)" 将删除尽可能多的尾随换行符，所以我以 ; 结尾... echo -na 并使用 echo -n "${line:0:-1}"：这会删除最后一个字符（即 a）并保留与输入中相同的尾随换行符（包括 no）。

我同意使用 sed：它是搜索/替换的最佳工具。这是我的方法：

$ cat template.txt
the number is ${i}
the dog's name is ${name}

$ cat replace.sed
s/${i}/5/
s/${name}/Fido/

$ sed -f replace.sed template.txt > out.txt

$ cat out.txt
the number is 5
the dog's name is Fido

我有一个像 mogsie 这样的 bash 解决方案，但使用 heredoc 而不是 herestring 可以避免转义双引号

eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null

尝试评估

我认为 eval 效果很好。它处理带有换行符、空格和各种 bash 内容的模板。如果您当然可以完全控制模板本身：

$ cat template.txt
variable1 = ${variable1}
variable2 = $variable2
my-ip = \"$(curl -s ifconfig.me)\"

$ echo $variable1
AAA
$ echo $variable2
BBB
$ eval "echo \"$(<template.txt)\"" 2> /dev/null
variable1 = AAA
variable2 = BBB
my-ip = "11.22.33.44"

当然，这个方法应该小心使用，因为 eval 可以执行任意代码。以 root 身份运行它几乎是不可能的。模板中的引号需要转义，否则会被eval吃掉。

如果您更喜欢 cat 而不是 echo，也可以使用此处的文档

$ eval "cat <<< \"$(<template.txt)\"" 2> /dev/null

@plockc 提出了一个避免 bash 引用转义问题的解决方案：

$ eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null

编辑：删除了关于使用 sudo 以 root 身份运行的部分...

编辑：添加了关于如何转义引号的评论，添加了 plockc 的解决方案！

编辑 2017 年 1 月 6 日

我需要在配置文件中保留双引号，因此使用 sed 双重转义双引号有助于：

render_template() {
  eval "echo \"$(sed 's/\"/\\\\"/g' $1)\""
}

我想不出保留尾随的新行，但保留了中间的空行。

虽然这是一个老话题，但 IMO 我在这里找到了更优雅的解决方案：http://pempek.net/articles/2013/07/08/bash-sh-as-template-engine/

#!/bin/sh

# render a template configuration file
# expand variables + preserve formatting
render_template() {
  eval "echo \"$(cat $1)\""
}

user="Gregory"
render_template /path/to/template.txt > path/to/configuration_file

Grégory Pakosz 的所有功劳。

envsubst 无需重新发明轮子，几乎可以在任何场景中使用，例如从 docker 容器中的环境变量构建配置文件。

如果在 mac 上确保你有 homebrew 然后从 gettext 链接它：

brew install gettext
brew link --force gettext

./template.cfg

# We put env variables into placeholders here
this_variable_1 = ${SOME_VARIABLE_1}
this_variable_2 = ${SOME_VARIABLE_2}

./.env：

SOME_VARIABLE_1=value_1
SOME_VARIABLE_2=value_2

./configure.sh

#!/bin/bash
cat template.cfg | envsubst > whatever.cfg

现在只需使用它：

# make script executable
chmod +x ./configure.sh
# source your variables
. .env
# export your variables
# In practice you may not have to manually export variables 
# if your solution depends on tools that utilise .env file 
# automatically like pipenv etc. 
export SOME_VARIABLE_1 SOME_VARIABLE_2
# Create your config file
./configure.sh

我会这样做，可能效率较低，但更容易阅读/维护。

TEMPLATE='/path/to/template.file'
OUTPUT='/path/to/output.file'

while read LINE; do
  echo $LINE |
  sed 's/VARONE/NEWVALA/g' |
  sed 's/VARTWO/NEWVALB/g' |
  sed 's/VARTHR/NEWVALC/g' >> $OUTPUT
done < $TEMPLATE

如果您想使用 Jinja2 模板，请参阅此项目：j2cli。

它支持：

来自 JSON、INI、YAML 文件和输入流的模板

从环境变量模板化

已接受答案的更长但更强大的版本：

perl -pe 's;(\\*)(\$([a-zA-Z_][a-zA-Z_0-9]*)|\$\{([a-zA-Z_][a-zA-Z_0-9]*)\})?;substr($1,0,int(length($1)/2)).($2&&length($1)%2?$2:$ENV{$3||$4});eg' template.txt

这会将 $VAR 或 ${VAR} 的所有实例扩展为它们的环境值（或者，如果它们未定义，则为空字符串）。

它正确地转义了反斜杠，并接受一个反斜杠转义的 $ 来禁止替换（与 envsubst 不同，事实证明，它不会这样做）。

因此，如果您的环境是：

FOO=bar
BAZ=kenny
TARGET=backslashes
NOPE=engi

你的模板是：

Two ${TARGET} walk into a \\$FOO. \\\\
\\\$FOO says, "Delete C:\\Windows\\System32, it's a virus."
$BAZ replies, "\${NOPE}s."

结果将是：

Two backslashes walk into a \bar. \\
\$FOO says, "Delete C:\Windows\System32, it's a virus."
kenny replies, "${NOPE}s."

如果您只想在 $ 之前转义反斜杠（您可以在未更改的模板中编写“C:\Windows\System32”），请使用这个稍微修改过的版本：

perl -pe 's;(\\*)(\$([a-zA-Z_][a-zA-Z_0-9]*)|\$\{([a-zA-Z_][a-zA-Z_0-9]*)\});substr($1,0,int(length($1)/2)).(length($1)%2?$2:$ENV{$3||$4});eg' template.txt

这是另一个解决方案：使用模板文件的所有变量和内容生成一个 bash 脚本，该脚本如下所示：

word=dog           
i=1                
cat << EOF         
the number is ${i} 
the word is ${word}

EOF                

如果我们将此脚本输入 bash，它将产生所需的输出：

the number is 1
the word is dog

以下是如何生成该脚本并将该脚本输入 bash：

(
    # Variables
    echo word=dog
    echo i=1

    # add the template
    echo "cat << EOF"
    cat template.txt
    echo EOF
) | bash

讨论

括号打开一个子shell，其目的是将所有生成的输出组合在一起

在子 shell 中，我们生成所有变量声明

同样在子shell中，我们使用HEREDOC生成cat命令

最后，我们将 sub shell 输出提供给 bash 并产生所需的输出

如果您想将此输出重定向到文件中，请将最后一行替换为：) | bash > 输出.txt

这是另一个纯 bash 解决方案：

它使用heredoc，因此：复杂性不会增加，因为额外需要的语法模板可以包含bash代码，它还允许您正确缩进内容。见下文。

由于额外需要语法，复杂性不会增加

模板可以包含 bash 代码，这些代码还允许您正确缩进。见下文。

这也允许您正确缩进。见下文。

它不使用 eval，所以： 渲染尾随空行没有问题 模板中的引号没有问题

尾随空行的渲染没有问题

模板中的引号没有问题

$ cat code

#!/bin/bash
LISTING=$( ls )

cat_template() {
  echo "cat << EOT"
  cat "$1"
  echo EOT
}

cat_template template | LISTING="$LISTING" bash

输入：
$ cat template（带有尾随换行符和双引号）

<html>
  <head>
  </head>
  <body> 
    <p>"directory listing"
      <pre>
$( echo "$LISTING" | sed 's/^/        /' )
      <pre>
    </p>
  </body>
</html>

输出：

<html>
  <head>
  </head>
  <body> 
    <p>"directory listing"
      <pre>
        code
        template
      <pre>
    </p>
  </body>
</html>

使用纯 bash 从 ZyX 获取答案，但使用新样式的正则表达式匹配和间接参数替换，它变为：

#!/bin/bash
regex='\$\{([a-zA-Z_][a-zA-Z_0-9]*)\}'
while read line; do
    while [[ "$line" =~ $regex ]]; do
        param="${BASH_REMATCH[1]}"
        line=${line//${BASH_REMATCH[0]}/${!param}}
    done
    echo $line
done

如果使用 Perl 是一种选择，并且您满足于仅基于 环境 变量的扩展（而不是所有 shell 个变量），考虑 Stuart P. Bentley's robust answer。

expandVars() {
  local txtToEval=$* txtToEvalEscaped
  # If no arguments were passed, process stdin input.
  (( $# == 0 )) && IFS= read -r -d '' txtToEval
  # Disable command substitutions and arithmetic expansions to prevent execution
  # of arbitrary commands.
  # Note that selectively allowing $((...)) or $[...] to enable arithmetic
  # expressions is NOT safe, because command substitutions could be embedded in them.
  # If you fully trust or control the input, you can remove the `tr` calls below
  IFS= read -r -d '' txtToEvalEscaped < <(printf %s "$txtToEval" | tr '`([' '\1\2\3')
  # Pass the string to `eval`, escaping embedded double quotes first.
  # `printf %s` ensures that the string is printed without interpretation
  # (after processing by by bash).
  # The `tr` command reconverts the previously escaped chars. back to their
  # literal original.
  eval printf %s "\"${txtToEvalEscaped//\"/\\\"}\"" | tr '\1\2\3' '`(['
}

$ expandVars '\$HOME="$HOME"; `date` and $(ls)'
$HOME="/home/jdoe"; `date` and $(ls)  # only $HOME was expanded

$ printf '\$SHELL=${SHELL}, but "$(( 1 \ 2 ))" will not expand' | expandVars
$SHELL=/bin/bash, but "$(( 1 \ 2 ))" will not expand # only ${SHELL} was expanded

 IFS= read -d '' -r lines # read all input from stdin at once
 end_offset=${#lines}
 while [[ "${lines:0:end_offset}" =~ (.*)\$(\{([a-zA-Z_][a-zA-Z_0-9]*)\}|([a-zA-Z_][a-zA-Z_0-9]*))(.*) ]] ; do
      pre=${BASH_REMATCH[1]} # everything before the var. reference
      post=${BASH_REMATCH[5]}${lines:end_offset} # everything after
      # extract the var. name; it's in the 3rd capture group, if the name is enclosed in {...}, and the 4th otherwise
      [[ -n ${BASH_REMATCH[3]} ]] && varName=${BASH_REMATCH[3]} || varName=${BASH_REMATCH[4]}
      # Is the var ref. escaped, i.e., prefixed with an odd number of backslashes?
      if [[ $pre =~ \\+$ ]] && (( ${#BASH_REMATCH} % 2 )); then
           : # no change to $lines, leave escaped var. ref. untouched
      else # replace the variable reference with the variable's value using indirect expansion
           lines=${pre}${!varName}${post}
      fi
      end_offset=${#pre}
 done
 printf %s "$lines"