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

Question

我正在编写一个脚本来自动为我自己的网络服务器创建 Apache 和 PHP 的配置文件。我不想使用任何 GUI，如 CPanel 或 ISPConfig。

我有一些 Apache 和 PHP 配置文件的模板。 Bash 脚本需要读取模板，进行变量替换并将解析后的模板输出到某个文件夹中。最好的方法是什么？我可以想出几种办法。哪一种是最好的，或者可能有一些更好的方法可以做到这一点？我想在纯 Bash 中执行此操作（例如，在 PHP 中很容易）

1. 如何替换文本文件中的 ${} 占位符？

template.txt:

The number is ${i}
The word is ${word}

script.sh:

#!/bin/sh

#set variables
i=1
word="dog"
#read in template one line at the time, and replace variables
#(more natural (and efficient) way, thanks to Jonathan Leffler)
while read line
do
    eval echo "$line"
done < "./template.txt"

顺便说一句，如何将输出重定向到此处的外部文件？如果变量包含引号，我是否需要转义某些内容？

2. 使用 cat & sed 用它的值替换每个变量：

给定 template.txt （见上文）

命令：

cat template.txt | sed -e "s/\${i}/1/" | sed -e "s/\${word}/dog/"

对我来说似乎很糟糕，因为需要转义许多不同的符号，并且对于许多变量，该行将太长。

您能想到其他优雅且安全的解决方案吗？

Answer 1

尝试 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).

Answer 2

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的回答: envsubst 对我来说是新的。极好的。

Answer 3

您可以使用以下命令：

perl -p -i -e 's/\$\{([^}]+)\}/defined $ENV{$1} ? $ENV{$1} : 
amp;/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="
 警告：我不知道如何正确处理 bash 中的 NUL 输入或保留尾随换行符的数量。最后一个变体之所以如此呈现，是因为 shell“喜欢”二进制输入：

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

$VARNAME'"'
    line="$PRE$VARVAL$POST"
    end_offset=${#PRE}
done
echo -n "${line:0:-1}"

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

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

Answer 4

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

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

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

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

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

Answer 5

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

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

Answer 6

尝试 eval

我认为 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 的解决方案！

Answer 7

编辑 2017 年 1 月 6 日

我需要在配置文件中保留双引号，因此使用 sed 进行双转义双引号会有所帮助：

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

我无法想到保留尾随新行，但会保留中间的空行。

---

虽然这是一个老话题，但我在这里找到了更优雅的解决方案： 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

所有功劳都归功于格雷戈里·帕科斯。

Answer 8

与其重新发明轮子，不如使用 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

Answer 9

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

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

Answer 10

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

它支持：

• 来自 JSON、INI、YAML 文件和输入流的模板
• 来自环境变量的模板

Answer 11

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

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

Answer 12

这是另一个解决方案：生成一个包含所有变量和模板文件内容的 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 中，我们生成 cat 命令与 HEREDOC
• 最后，我们将子 shell 输出提供给 bash 并生成所需的输出

• 如果您想将此输出重定向到文件中，请将最后一行替换为：

  <前><代码>) |重击>输出.txt

Answer 13

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

• 它使用heredoc，所以：
  • 复杂性不会因为额外所需的语法而增加
  • 模板可以包含 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>

Answer 14

使用纯 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

Answer 15

如果使用Perl是一种选择，并且您满足于仅基于环境变量进行基础扩展（而不是所有shell 变量），考虑Stuart P. Bentley 的稳健答案。

这个答案旨在提供一个仅 bash 的解决方案，尽管使用了eval - 应该可以安全使用。

目标是：

• 支持${name}和$name变量引用的扩展。
• 阻止所有其他扩展：
  • 命令替换（$(...) 和旧语法 `...`）
  • 算术替换（$((...)) 和旧语法 $[...]）。
• 允许通过添加前缀 \ (\${name}) 来选择性地抑制变量扩展。
• 保留特殊字符。在输入中，特别是 " 和 \ 实例。
• 允许通过参数或标准输入输入。

函数 expandVars()

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

• 出于性能原因，该函数将 stdin 输入一次性读取到内存中，但也可以轻松地将函数调整为逐行方法。
• > 支持非基本变量扩展，例如${HOME:0:10}，只要它们不包含嵌入式命令或算术替换，例如${首页：0：$（回显10）}
  • 此类嵌入替换实际上会破坏函数（因为所有 $( 和 ` 实例都会被盲目转义）。
  • 同样，格式错误的变量引用，例如 ${HOME（缺少结束 }）会破坏函数。
• 由于 bash 对双引号字符串的处理，反斜杠的处理方式如下：
  • \$name 防止扩展。
  • 后面不跟 $ 的单个 \ 将按原样保留。
  • 如果要表示多个相邻 \ 实例，则必须将它们加倍；例如：
    • \\ -> \ - 与 \

    相同

    • \\\\ -> <代码>\\
  • 输入内容不得包含以下（很少使用）字符，这些字符用于内部用途：0x1、0x2、0x3 .
• 很大程度上假设的担忧是，如果 bash 应引入新的扩展语法，此函数可能无法阻止此类扩展 - 请参阅下面的不使用 eval 的解决方案。

---

如果您正在寻找限制性更强的解决方案，仅支持${name}扩展 - 即强制 > 大括号，忽略 $name 引用 - 请参阅我的这个答案。

---

这是来自已接受的答案<的仅 bash、eval-free 解决方案的改进版本/a>：

改进如下：

• 支持扩展 ${name} 和 $name 变量引用。
• 支持 \ - 转义不应扩展的变量引用。
• 与上面基于 eval 的解决方案不同，
  • 非基本扩展将被忽略
  • 格式错误的变量引用将被忽略（它们不会破坏脚本）

 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"

Answer 16

为了跟进本页上的plockc的答案，这里有一个适合破折号的版本，适合那些希望避免bashisms的人。

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

Answer 17

尝试 shtpl

shtpl 的完美案例。 （我的项目，所以它没有被广泛使用并且缺乏文档。但是这里是它提供的解决方案。也许你想测试它。）

只需执行：

$ i=1 word=dog sh -c "$( shtpl template.txt )"

结果是：

the number is 1
the word is dog

玩得开心。

Answer 18

本页描述了使用 awk 的答案

awk '{while(match($0,"[$]{[^}]*}")) {var=substr($0,RSTART+2,RLENGTH -3);gsub("[$]{"var"}",ENVIRON[var])}}1' < input.txt > output.txt

Answer 19

# Usage: template your_file.conf.template > your_file.conf
template() {
        local IFS line
        while IFS=
这是纯 bash 函数，可根据您的喜好进行调整，在生产中使用，并且不应因任何输入而中断。

如果它坏了 - 请告诉我。
\n\r' read -r line ; do
                line=${line//\\/\\\\}         # escape backslashes
                line=${line//\"/\\\"}         # escape "
                line=${line//\`/\\\`}         # escape `
                line=${line//\$/\\\$}         # escape $
                line=${line//\\\${/\${}       # de-escape ${         - allows variable substitution: ${var} ${var:-default_value} etc
                # to allow arithmetic expansion or command substitution uncomment one of following lines:
#               line=${line//\\\$\(/\$\(}     # de-escape $( and $(( - allows $(( 1 + 2 )) or $( command ) - UNSECURE
#               line=${line//\\\$\(\(/\$\(\(} # de-escape $((        - allows $(( 1 + 2 ))
                eval "echo \"${line}\"";
        done < "$1"
}

这是纯 bash 函数，可根据您的喜好进行调整，在生产中使用，并且不应因任何输入而中断。
如果它坏了 - 请告诉我。

Answer 20

您还可以使用bashible（它内部使用上面/下面描述的评估方法）。

有一个示例，如何从多个部分生成 HTML：

https://github .com/mig1984/bashible/tree/master/examples/templates

Answer 21

在这里查看简单的变量替换 python 脚本： https://github.com/jeckep/vsubst

它是使用非常简单：

python subst.py --props secure.properties --src_path ./templates --dst_path ./dist

Answer 22

您可以使用带有环境变量的模板文件并运行

cat template-file.yaml |envsubst

Answer 23

这是一个保留空格的 bash 函数：

# Render a file in bash, i.e. expand environment variables. Preserves whitespace.
function render_file () {
    while IFS='' read line; do
        eval echo \""${line}"\"
    done < "${1}"
}

Answer 24

这是一个基于其他一些答案的修改后的 perl 脚本：

perl -pe 's/([^\\]|^)\$\{([a-zA-Z_][a-zA-Z_0-9]*)\}/$1.$ENV{$2}/eg' -i template

功能（基于我的需要，但应该很容易修改）：

• 跳过转义参数扩展（例如 \${VAR}）。
• 支持 ${VAR} 形式的参数扩展，但不支持 $VAR。
• 如果没有 VAR envar，则将 ${VAR} 替换为空白字符串。
• 名称中仅支持 az、AZ、0-9 和下划线字符（不包括第一个位置的数字）。

Answer 25

您还可以使用 printf 来填充模板。

#!/bin/bash

IFS='' read -rd '' TEMPL <<-'EOB'
The number is %d
The word is "%s"
Birds of Massachusetts:
    %s




EOB

N=12
WORD="Bird"
MULTILINE="Eastern Bluebirds
Common Grackles"

echo "START"
printf "${TEMPL}" ${N} ${WORD} "${MULTILINE}"
echo "END"

这是输出，引号和空格完好无损：

START
The number is 12
The word is "Bird"
Birds of Massachusetts:
    Eastern Bluebirds
Common Grackles




END

Answer 26

我一直在寻找一个仅标准实用程序的解决方案，而且我对评估任意模板感到不舒服——这很容易出错。最终我想出了以下方法。

模板文件：

$ cat addusers.template.sh 
# Available variables:
# $USER_NAME
# $USER_ID
# $USER_GROUP_ID

adduser --uid $USER_ID --gid $USER_GROUP_ID --gecos '' --disabled-password $USER_NAME
cp -v /tmp/bash.rc /home/$USER_NAME/.bashrc
chown -v $USER_ID:$USER_GROUP_ID /home/$USER_NAME/.bashrc
chmod 444 /home/$USER_NAME/.bashrc

Bash 脚本：

$ cat cook-addusers.sh
# Read template file skipping comments and empty lines
TEMPLATE="$(grep -vE -e '^[[:blank:]]*#' -e '^[[:blank:]]*
以及运行它的结果：
$ ./cook-addusers.sh
$ cat generated.sh 
adduser --uid 1001 --gid 101 --gecos '' --disabled-password admin
cp -v /tmp/bash.rc /home/admin/.bashrc
chown -v 1001:101 /home/admin/.bashrc
chmod 444 /home/admin/.bashrc
adduser --uid 1010 --gid 101 --gecos '' --disabled-password superuser
cp -v /tmp/bash.rc /home/superuser/.bashrc
chown -v 1010:101 /home/superuser/.bashrc
chmod 444 /home/superuser/.bashrc
adduser --uid 1100 --gid 101 --gecos '' --disabled-password supervisor
cp -v /tmp/bash.rc /home/supervisor/.bashrc
chown -v 1100:101 /home/supervisor/.bashrc
chmod 444 /home/supervisor/.bashrc

它相当粗糙，但似乎在典型的 Linux 和 BSD 上都按预期工作......抱歉，我的意思是 macOS ;-)
 addusers.template.sh)"

# Cook regex template with the list of substituted variables
for VAR in USER_NAME USER_ID USER_GROUP_ID; do
    RE="${RE}"'s/\
以及运行它的结果：

它相当粗糙，但似乎在典型的 Linux 和 BSD 上都按预期工作......抱歉，我的意思是 macOS ;-)
$VAR'/
以及运行它的结果：

它相当粗糙，但似乎在典型的 Linux 和 BSD 上都按预期工作......抱歉，我的意思是 macOS ;-)
$VAR'/g\; '
done

# Fill in the template for a list of users
for USER_NAME in admin superuser supervisor; do
    USER_ID=$(id -u "$USER_NAME")
    USER_GROUP_ID=$(id -g "$USER_NAME")
    sed "$(eval echo "$RE")" <<<"${TEMPLATE}"
done >generated.sh

以及运行它的结果：

它相当粗糙，但似乎在典型的 Linux 和 BSD 上都按预期工作......抱歉，我的意思是 macOS ;-)