Ich schreibe ein Skript, um das Erstellen von Konfigurationsdateien für Apache und PHP für meinen eigenen Webserver zu automatisieren. Ich möchte keine GUIs wie CPanel oder ISPConfig verwenden.

Ich habe einige Vorlagen für Apache- und PHP-Konfigurationsdateien. Das Bash-Skript muss Vorlagen lesen, Variablen ersetzen und analysierte Vorlagen in einem Ordner ausgeben. Was ist der beste Weg das zu tun? Ich kann mir verschiedene Möglichkeiten vorstellen. Welches ist das beste oder gibt es vielleicht bessere Möglichkeiten, das zu tun? Ich möchte das in reinem Bash machen (es ist zum Beispiel in PHP einfach)

1) Wie ersetze ich $ {} Platzhalter in einer Textdatei?

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"

Übrigens, wie leite ich die Ausgabe hier in eine externe Datei um? Muss ich etwas entkommen, wenn Variablen beispielsweise Anführungszeichen enthalten?

2) Verwenden von cat & sed zum Ersetzen jeder Variablen durch ihren Wert:

Gegeben template.txt:

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

Befehl:

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

Scheint mir schlecht zu sein, weil ich vielen verschiedenen Symbolen entkommen muss und bei vielen Variablen die Zeile zu lang ist.

Können Sie sich eine andere elegante und sichere Lösung vorstellen?

Sie können dies verwenden:

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

um alle ${...}Zeichenfolgen durch entsprechende Umgebungsvariablen zu ersetzen (vergessen Sie nicht, sie zu exportieren, bevor Sie dieses Skript ausführen).

Für Pure Bash sollte dies funktionieren (vorausgesetzt, Variablen enthalten keine $ {...} Strings):

#!/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

. Lösung, die nicht hängt, wenn RHS auf eine Variable verweist, die auf sich selbst verweist:

#!/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}"

WARNUNG : Ich kenne keine Möglichkeit, Eingaben mit NULs in Bash korrekt zu verarbeiten oder die Anzahl der nachgestellten Zeilenumbrüche beizubehalten. Die letzte Variante wird so dargestellt, wie sie ist, weil Shells die binäre Eingabe „lieben“:

1. read interpretiert Backslashes.
2. read -r interpretiert keine Backslashes, löscht jedoch die letzte Zeile, wenn sie nicht mit einer neuen Zeile endet.
3. "$(…)"wird so viele nachfolgende Zeilenumbrüche entfernen, wie vorhanden sind, also beende ich …mit ; echo -n aund verwende echo -n "${line:0:-1}": Dies löscht das letzte Zeichen (das ist a) und behält so viele nachfolgende Zeilenumbrüche bei, wie in der Eingabe vorhanden waren (einschließlich Nein).

Versuchen envsubst

FOO=foo
BAR=bar
export FOO BAR

envsubst <<EOF
FOO is $FOO
BAR is $BAR
EOF

envsubst war neu für mich. Fantastisch.

Für die Aufzeichnung ist die Verwendung eines Heredoc eine großartige Möglichkeit, eine Conf-Datei zu erstellen.

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

Ich bin mit der Verwendung von sed einverstanden: Es ist das beste Tool zum Suchen / Ersetzen. Hier ist mein Ansatz:

$ 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

Ich denke, eval funktioniert wirklich gut. Es verarbeitet Vorlagen mit Zeilenumbrüchen, Leerzeichen und allerlei Bash-Dingen. Wenn Sie die volle Kontrolle über die Vorlagen selbst haben, natürlich:

$ 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"

Diese Methode sollte natürlich mit Vorsicht angewendet werden, da eval beliebigen Code ausführen kann. Dies als root auszuführen kommt so gut wie nicht in Frage. Anführungszeichen in der Vorlage müssen maskiert werden, sonst werden sie von gegesseneval .

Sie können hier Dokumente verwenden , wenn Sie es vorziehen , catzuecho

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

@plockc hat eine Lösung gefunden, die das Problem des Bash-Zitats vermeidet:

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

Bearbeiten: Teil über das Ausführen als Root mit sudo entfernt ...

Bearbeiten: Kommentar hinzugefügt, wie Anführungszeichen maskiert werden müssen, Plockc-Lösung zum Mix hinzugefügt!

Ich habe eine Bash-Lösung wie Mogsie, aber mit Heredoc anstelle von Herestring, damit Sie nicht doppelten Anführungszeichen entkommen

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

Bearbeiten 6. Januar 2017

Ich musste doppelte Anführungszeichen in meiner Konfigurationsdatei behalten, damit doppelte Anführungszeichen mit sed helfen:

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

Ich kann mir nicht vorstellen, neue Zeilen zu verfolgen, aber dazwischen werden leere Zeilen beibehalten.

Obwohl es ein altes Thema ist, fand ich IMO hier eine elegantere Lösung: 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

Alle Credits an Grégory Pakosz .

Anstatt das Rad neu zu erfinden, gehen Sie mit envsubst Kann in fast jedem Szenario verwendet werden, z. B. zum Konfigurationsdateien aus Umgebungsvariablen in Docker-Containern.

Wenn Sie auf einem Mac sicherstellen, dass Sie Homebrew haben, verknüpfen Sie es mit 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

Jetzt benutze es einfach:

# 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

Eine längere, aber robustere Version der akzeptierten Antwort:

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

Dies erweitert alle Instanzen von $VAR oder ${VAR} auf ihre Umgebungswerte (oder, wenn sie nicht definiert sind, die leere Zeichenfolge).

Es entgeht Backslashes ordnungsgemäß und akzeptiert ein $ mit Backslash-Escape, um die Substitution zu verhindern (im Gegensatz zu envsubst, das dies, wie sich herausstellt, nicht tut ).

Also, wenn Ihre Umgebung ist:

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

und Ihre Vorlage ist:

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

das Ergebnis wäre:

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

Wenn Sie Backslashes nur vor $ vermeiden möchten (Sie könnten "C: \ Windows \ System32" unverändert in eine Vorlage schreiben), verwenden Sie diese leicht modifizierte Version:

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

Ich hätte es so gemacht, wahrscheinlich weniger effizient, aber einfacher zu lesen / zu warten.

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

Wenn Sie Jinja2- Vorlagen verwenden möchten , sehen Sie sich dieses Projekt an: j2cli .

Es unterstützt:

• Vorlagen aus JSON-, INI-, YAML-Dateien und Eingabestreams
• Vorlagen aus Umgebungsvariablen

Wenn Sie die Antwort von ZyX mit reinem Bash nehmen, aber mit neuem Regex-Matching und indirekter Parametersubstitution, wird es:

#!/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

Bei der Verwendung von Perl ist eine Option , und Sie sind zufrieden mit Erweiterungen auf stützen Umwelt nur Variablen (im Gegensatz zu allen gegenüberliegenden Shell - Variablen), betrachten Stuart P. Bentley robuste Antwort .

Diese Antwort zielt darauf ab, eine reine Bash-Lösung bereitzustellen , die trotz Verwendung sicher seineval sollte .

Die Ziele sind:

• Unterstützt die Erweiterung sowohl von ${name}als auch von $namevariablen Referenzen.
• Verhindern Sie alle anderen Erweiterungen:
  • Befehlsersetzungen ( $(...)und Legacy-Syntax `...`)
  • arithmetische Ersetzungen ( $((...))und Legacy-Syntax $[...]).
• Ermöglichen Sie die selektive Unterdrückung der Variablenerweiterung durch Präfixieren mit \(\${name} ).
• Bewahren Sie spezielle Zeichen auf. in der Eingabe, insbesondere "und \Instanzen.
• Eingabe entweder über Argumente oder über stdin zulassen.

FunktionexpandVars() :

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' '`(['
}

Beispiele:

$ 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

• Aus Leistungsgründen liest die Funktion die stdin-Eingabe auf einmal in den Speicher, aber es ist einfach, die Funktion zeilenweise anzupassen.
• Unterstützt auch nicht-grundlegende Variablenerweiterungen wie ${HOME:0:10}, solange sie keinen eingebetteten Befehl oder arithmetische Ersetzungen enthalten, wie z${HOME:0:$(echo 10)}
  • Solche eingebetteten Substitutionen unterbrechen die Funktion tatsächlich (weil alle $(und `Instanzen blind maskiert sind).
  • In ähnlicher Weise brechen fehlerhafte Variablenreferenzen wie ${HOME(fehlendes Schließen }) die Funktion.
• Aufgrund der Behandlung von Zeichenfolgen in doppelten Anführungszeichen durch bash werden Backslashes wie folgt behandelt:
  • \$name verhindert Expansion.
  • Eine einzelne, der \nicht gefolgt $wird, bleibt unverändert.
  • Wenn Sie mehrere benachbarte \ Instanzen darstellen möchten , müssen Sie diese verdoppeln . z.B:
    • \\-> \- das gleiche wie gerade\
    • \\\\ -> \\
  • Der Eingang muss nicht die folgenden enthalten (selten verwendet) Zeichen, die für interne Zwecke verwendet werden: 0x1, 0x2, 0x3.
• Es besteht ein weitgehend hypothetisches Problem, dass diese Funktion solche Erweiterungen möglicherweise nicht verhindert, wenn bash eine neue Erweiterungssyntax einführt. Eine Lösung, die nicht verwendet wird, finden Sie weiter unten eval.

Wenn Sie nach einer restriktiveren Lösung${name} suchen , die nur Erweiterungen unterstützt, dh mit obligatorischen geschweiften Klammern, die $nameReferenzen ignorieren, lesen Sie meine Antwort .

Hier ist eine verbesserte Version der Nur-Bash- evalfreien Lösung aus der akzeptierten Antwort :

Die Verbesserungen sind:

• Unterstützung für die Erweiterung von ${name}und $namevariablen Referenzen.
• Unterstützung für \ -scaping-Variablenreferenzen, die nicht erweitert werden sollten.
• Im Gegensatz zu der evalobigen Lösung auf Basis von
  • Nicht grundlegende Erweiterungen werden ignoriert
  • fehlerhafte Variablenreferenzen werden ignoriert (sie brechen das Skript nicht)

 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"

Hier ist eine weitere reine Bash-Lösung:

• es verwendet Heredoc, also:
  • Die Komplexität nimmt aufgrund der zusätzlich erforderlichen Syntax nicht zu
  • Vorlage kann Bash-Code enthalten
    • das erlaubt dir auch, Sachen richtig einzurücken. Siehe unten.
• eval wird nicht verwendet, also:
  • Keine Probleme beim Rendern von nachgestellten Leerzeilen
  • Keine Probleme mit Anführungszeichen in der Vorlage

$ cat code

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

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

cat_template template | LISTING="$LISTING" bash

$ cat template (mit nachgestellten Zeilenumbrüchen und doppelten Anführungszeichen)

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

Ausgabe

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

Hier ist eine andere Lösung: Generieren Sie ein Bash-Skript mit allen Variablen und dem Inhalt der Vorlagendatei. Dieses Skript würde folgendermaßen aussehen:

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

EOF                

Wenn wir dieses Skript in bash einspeisen, wird die gewünschte Ausgabe erzeugt:

the number is 1
the word is dog

So generieren Sie dieses Skript und geben es in bash ein:

(
    # Variables
    echo word=dog
    echo i=1

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

Diskussion

• Die Klammern öffnen eine Unter-Shell, deren Zweck darin besteht, alle generierten Ausgaben zu gruppieren
• Innerhalb der Subshell generieren wir alle Variablendeklarationen
• Auch in der catSubshell generieren wir den Befehl mit HEREDOC
• Schließlich geben wir die Sub-Shell-Ausgabe an bash weiter und erzeugen die gewünschte Ausgabe

• Wenn Sie diese Ausgabe in eine Datei umleiten möchten, ersetzen Sie die letzte Zeile durch:

  ) | bash > output.txt

Diese Seite beschreibt eine Antwort mit awk

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

Perfekter Fall für shtpl . (Projekt von mir, daher ist es nicht weit verbreitet und es fehlt an Dokumentation. Aber hier ist die Lösung, die es trotzdem bietet. Vielleicht möchten Sie es testen.)

Einfach ausführen:

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

Ergebnis ist:

the number is 1
the word is dog

Habe Spaß.

# Usage: template your_file.conf.template > your_file.conf
template() {
        local IFS line
        while IFS=$'\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"
}

Dies ist die reine Bash-Funktion, die nach Ihren Wünschen einstellbar ist, in der Produktion verwendet wird und bei keiner Eingabe unterbrochen werden sollte. Wenn es kaputt geht - lass es mich wissen.

Sie können auch bashible verwenden (das intern den oben / unten beschriebenen Bewertungsansatz verwendet).

Es gibt ein Beispiel, wie ein HTML aus mehreren Teilen generiert wird:

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

Hier ist eine Bash-Funktion, die Leerzeichen beibehält:

# 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}"
}

Hier ist ein modifiziertes perlSkript, das auf einigen der anderen Antworten basiert:

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

Funktionen (basierend auf meinen Anforderungen, sollten aber leicht zu ändern sein):

• Überspringt entkommene Parametererweiterungen (z. B. \ $ {VAR}).
• Unterstützt Parametererweiterungen der Form $ {VAR}, jedoch nicht $ VAR.
• Ersetzt $ {VAR} durch eine leere Zeichenfolge, wenn kein VAR-Envar vorhanden ist.
• Unterstützt nur Az-, AZ-, 0-9- und Unterstrichzeichen im Namen (ausgenommen Ziffern an der ersten Position).

Sehen Sie sich hier das Python-Skript zur einfachen Substitution von Variablen an: https://github.com/jeckep/vsubst

Es ist sehr einfach zu bedienen:

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

Mein bescheidener Beitrag zu dieser wunderbaren Frage.

tpl() {
    local file=$(cat - | \
                 sed -e 's/\"/\\"/g' \
                     -e "s/'/\\'/g")
    local vars=$(echo ${@} | tr ' ' ';')
    echo "$(sh -c "${vars};echo \"$file\"")"
}

cat tpl.txt | tpl "one=fish" "two=fish"

Dies funktioniert im Wesentlichen, indem die Subshell zum Ersetzen von Envars verwendet wird, mit der Ausnahme, dass eval nicht verwendet wird und explizite einfache und doppelte Anführungszeichen vermieden werden. Es verkettet die var-Ausdrücke in einer einzigen Zeile ohne zu verwirrende Leerzeichen shund übergibt dann die Vorlage an echo, sodass shdie var-Ersetzungen verarbeitet werden können. Es behält Zeilenumbrüche, Kommentare usw. bei und Sie können entkommen, \${like_this}wenn Sie nicht möchten, dass die Variable interpretiert wird. ${missing_var}wird nur durch einen leeren Wert ersetzt.

Viele der anderen Antworten hier sind sehr gut, aber ich wollte etwas sehr Einfaches und es muss nicht buchstäblich jeden möglichen Fall für die Vorlagenfälle behandeln, die ich derzeit habe.

Genießen!

Um die Antwort von plockc auf dieser Seite weiterzuverfolgen , finden Sie hier eine für das Dash geeignete Version für diejenigen unter Ihnen, die Bashismen vermeiden möchten.

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

Einfacher geht es nicht als:

$ person = Bob ./render template.txt> render.txt

Siehe https://github.com/relaxdiego/renderest