Bash Templating: Wie man Konfigurationsdateien aus Vorlagen mit Bash erstellt?

Ich Schreibe ein Skript zum automatisieren der Erstellung von Konfigurationsdateien für Apache und PHP auf meinem eigenen webserver. Ich will nicht von irgendwelchen GUIs, wie CPanel oder ISPConfig.

Ich habe einige Vorlagen von PHP und Apache-Konfigurationsdateien. Bash-Skript Lesen muss Vorlagen, machen Variablenzuweisung und Ausgabe analysiert Vorlagen in einem Ordner. Was ist der beste Weg, das zu tun? Ich kann mir denken, von mehreren Möglichkeiten. Welche ist die beste oder vielleicht gibt es einige bessere Möglichkeiten, das zu tun? Ich möchte zu tun, dass in reinen Bash (es ist einfach, in PHP zum Beispiel)

1) So ersetzen Sie $ {} - Platzhalter in eine text-Datei?

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"

BTW, wie kann ich die Umleitung der Ausgabe auf externen Datei hier? Brauche ich, um zu entkommen etwas, wenn Sie Variablen enthalten, sagen, Zitate?

2) Mit Hilfe von cat & sed für die Ersetzung der einzelnen 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/"

Schlecht scheint mir wegen der zu entkommen müssen viele verschiedene Symbole und mit vielen Variablen die Zeile tooooo lange.

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

InformationsquelleAutor der Frage Vladislav Rastrusny | 2010-05-26

46

Diese:
```
perl -p -i -e 's/\$\{([^}]+)\}/defined $ENV{$1} ? $ENV{$1} : $&/eg' < template.txt
```
ersetzen alle ${...} strings mit entsprechenden Umgebungs-Variablen (nicht vergessen zu exportieren, um Sie vor dem ausführen dieses Skripts).

Für Reine bash sollte das funktionieren (vorausgesetzt, die Variablen sind nicht enthalten $ { ... } - 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ängen, wenn RHS Referenzen einige Variablen, die Referenzen selbst:
```
#!/bin/bash 
Zeile="$(cat; echo -n a)" 
end_offset=${#Zeile} 
while [[ "${Zeile:0:$end_offset}" =~ (.*)(\$\{([a-zA-Z_][a-zA-Z_0-9]*)\})(.*) ]] ; tun 
PRE="${BASH_REMATCH[1]}" 
POST="${BASH_REMATCH[4]}${Zeile:$end_offset:${#line}}" 
VARNAME="${BASH_REMATCH[3]}" 
eval 'VARVAL="$'$VARNAME'"' 
Zeile="$PRE$VARVAL$POST" 
end_offset=${#PRE} 
getan 
echo -n "${Zeile:0:-1}" 
```
WARNUNG: ich weiß nicht, einen Weg, um richtig behandeln-Eingang mit NULs in bash oder bewahren Sie die Menge der nachfolgende Zeilenumbrüche. Die Letzte Variante wird vorgestellt, wie es ist, weil Muscheln "Liebe" binary input:
1. read interpretiert backslashes.
2. read -r wird nicht interpretiert backslashes, aber immer noch sinkt die Letzte Zeile, wenn es endet nicht mit einem newline.
3. "$(…)" Streifen als viele nachfolgende Zeilenumbrüche da sind vorhanden, so dass ich am Ende … mit ; echo -n a und verwenden echo -n "${line:0:-1}": dies löscht das Letzte Zeichen (das ist a) und bewahrt so viele nachfolgende Zeilenumbrüche, wie es war, in die Eingabe (einschließlich keine).
InformationsquelleAutor der Antwort ZyX

Versuchen envsubst

FOO=foo
BAR=bar
export FOO BAR

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

InformationsquelleAutor der Antwort yottatsa

envsubst war mir neu. Fantastisch.

Für die Aufzeichnung, mit einem heredoc ist ein guter Weg, um Vorlage einer conf-Datei.

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

InformationsquelleAutor der Antwort Dan Garthwaite

Stimme ich mit sed: es ist das beste Werkzeug für das 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

InformationsquelleAutor der Antwort Hai Vu

15

Ich denke eval funktioniert wirklich gut. Er verarbeitet Vorlagen mit Zeilenumbrüche, Leerzeichen, und alle Arten von bash Zeug. Wenn Sie haben die volle Kontrolle über die Vorlagen selbst 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 mit Vorsicht verwendet werden, da eval kann, beliebigen code auszuführen. Ausgeführt als root ist so ziemlich außer Frage. Zitate, die in der Vorlage müssen maskiert werden, sonst werden Sie gefressen eval.

Können Sie auch hier Dokumente, wenn Sie es vorziehen cat zu echo
```
$ eval "cat <<< \"$(<template.txt)\"" 2> /dev/null
```
@plockc provoded eine Lösung, die vermeidet, dass die bash-quote escaping-Problem:
```
$ eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null
```
Edit: Entfernt Teil zum ausführen als root mit sudo...

Edit: Hinzugefügt Kommentar darüber, wie Zitate müssen escaped werden, Hinzugefügt plockc die Lösung für das mischen!

InformationsquelleAutor der Antwort mogsie
15

Bearbeiten, Jan 6, 2017

Ich benötigt, um doppelte Anführungszeichen in meiner Konfiguration-Datei, so double escaping von double-quotes mit sed hilft:
```
render_template() {
  eval "echo \"$(sed 's/\"/\\\\"/g' $1)\""
}
```
Kann ich nicht denken, um nachfolgende neue Zeilen, leere Zeilen dazwischen gehalten werden.

Es ist zwar ein altes Thema, IMO fand ich heraus, elegantere Lösung hier: 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 Kredite an Grégory Pakosz.

InformationsquelleAutor der Antwort CKK
13

Habe ich ein bash-Lösung wie mogsie aber mit der heredoc-statt herestring Ihnen zu erlauben, vermeiden, entkommen Anführungszeichen
```
eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null
```
InformationsquelleAutor der Antwort plockc

Ich würde getan haben, es auf diese Weise wahrscheinlich weniger effizient, aber einfacher zu Lesen/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

InformationsquelleAutor der Antwort Craig552uk

8

Länger, 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
```
Diese erweitert alle Instanzen von $VAR oder ${VAR} zu Ihrer Umwelt-Werten (oder, wenn Sie undefined ist, wird die leere Zeichenfolge).

Es richtig entweicht, umgekehrte Schrägstriche, und akzeptiert eine backslash-Escape - $ zu hemmen substitution (im Gegensatz zu envsubst, die es stellt sich heraus, dies nicht tut).

Also, wenn Ihre Umgebung:
```
FOO=bar
BAZ=kenny
TARGET=backslashes
NOPE=engi
```
und Ihre Vorlage:
```
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 nur wollen, zu entkommen Backslash vor dem $ (man könnte schreiben "C:\Windows\System32" in einer Vorlage unverändert), 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
```
InformationsquelleAutor der Antwort Stuart P. Bentley
6

Wenn Sie verwenden möchten Jinja2 Vorlagen finden Sie dieses Projekt: j2cli.

Unterstützt:
- Vorlagen von JSON, INI, YAML-Dateien und input-streams
- Templating von Umgebungsvariablen
InformationsquelleAutor der Antwort kolypto

Unter der Antwort von ZyX mit reinen bash, aber mit neuen Stil regex-matching und indirekte parameter-substitution 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

InformationsquelleAutor der Antwort wich

4

Wenn mit Perl eine option ist, und du damit zufrieden bist, mit stützend-Erweiterungen auf Umgebung Variablen nur (im Gegensatz zu allen shell Variablen), betrachten Stuart P. Bentley robuste Antwort.

Diese Antwort zielt darauf ab, eine bash-only-Lösungdass - trotz Verwendung von eval - sollte sicher zu verwenden.

Den Ziele sind:
- Unterstützung der expansion sowohl ${name} und $name variable referenziert.
- Verhindern, dass alle anderen Erweiterungen:
  - command substitutions ($(...)- und legacy-syntax `...`)
  - arithmetische Substitutionen ($((...))- und legacy-syntax $[...]).
- Ermöglichen die selektive Unterdrückung der variable expansion durch das voranstellen \ (\${name}).
- Bewahren besonderen chars. in der Eingabe, insbesondere " und \ Instanzen.
- Eingabe entweder über Argumente oder über stdin.
Funktion 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' '`(['
}
```
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 performance-Gründen die Funktion liest von stdin input alle auf einmal in den Speicher, aber es ist einfach zu passen Sie die Funktion an eine line-by-line-Ansatz.
- Unterstützt auch non-basic variable Erweiterungen wie ${HOME:0:10}solange Sie enthalten keine eingebetteten Befehl oder arithmetische Substitutionen, wie ${HOME:0:$(echo 10)}
  - Solche embedded-Substitutionen tatsächlich BRECHEN Sie die Funktion aus (weil alle $( und ` Instanzen sind blind geflohen).
  - Ähnlich, fehlerhafte Variablen-Referenzen wie ${HOME (fehlendes }) BRECHEN Sie die Funktion.
- Aufgrund der bash auch das handling von double-quoted strings, backslashes werden wie folgt behandelt:
  - \$name verhindert die expansion.
  - Einem einzigen \ nicht gefolgt von $ erhalten ist, wie Sie ist.
  - Wenn Sie repräsentieren wollen mehrere benachbarte \ Instanzen, müssen Sie doppelklicken Sie; z.B.:
    
    \\ -> \ - das gleiche wie gerade \
    
    \\\\ -> \\
  - Die Eingabe darf nicht enthalten sind folgende (selten gebrauchte) Zeichen, die verwendet werden, für interne Zwecke: 0x10x20x3.
- Es gibt eine weitgehend hypothetische Sorge, dass, wenn die bash sollte die Einführung neuer expansion-syntax diese Funktion kann nicht verhindern, dass solche Erweiterungen - siehe weiter unten für eine Lösung, die nicht eval.
Wenn Sie sich für eine restriktivere Lösung, die nur unterstützt ${name} Erweiterungen - d.h., mit zwingend geschweiften Klammern, ignorieren $name Referenzen - siehe diese Antwort von mir.

Hier ist ein verbesserte version der bash-nur eval-freie Lösung von der akzeptierte Antwort:

Verbesserungen sind:
- Unterstützung für den ausbau der beiden ${name} und $name variable referenziert.
- Unterstützung für \-Flucht-variable referenziert, das sollte nicht erweitert werden.
- Im Gegensatz zu den eval-basierte Lösung vor,
  - non-basic Erweiterungen werden ignoriert
  - fehlerhafte variable, die Verweise werden ignoriert (Sie brechen nicht das Skript)
```
 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"
```
InformationsquelleAutor der Antwort mklement0

Diese Seite beschreibt ein Antwort mit awk

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

InformationsquelleAutor der Antwort Matt Brown

3

Perfekte Fall für shtpl. (Projekt von mir, also es ist nicht weit verbreitet und fehlt in der Dokumentation. Aber hier ist die Lösung bietet es jedenfalls. Können Sie es testen wollen.)

Nur ausführen:
```
$ i=1 word=dog sh -c "$( shtpl template.txt )"
```
Ergebnis ist:
```
the number is 1
the word is dog
```
Spaß haben.

InformationsquelleAutor der Antwort zstegi

Hier ist ein reines bash-Lösung:

es mit der heredoc, also:
- Komplexität nicht erhöhen, da der zusätzlich erforderliche syntax
- Vorlage kann enthalten bash-code
  - können Sie auch Einzug Zeug richtig. Siehe unten.
es nicht mit eval, also:
- keine Probleme mit dem rendering von leere Zeilen
- 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 nachfolgenden Zeilenumbrüche und 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>

InformationsquelleAutor der Antwort Tomáš Pospíšek

2

Hier ist eine andere Lösung: erstellen Sie ein bash-script mit den Variablen und den Inhalt der template-Datei, das script würde so Aussehen:
```
word=dog           
i=1                
cat << EOF         
the number is ${i} 
the word is ${word}

EOF                
```
Wenn wir füttern dieses Skript in bash wäre es erzeugen Sie die gewünschte Ausgabe:
```
the number is 1
the word is dog
```
Hier ist, wie zu generieren, das Skript und Futter, das Skript in bash:
```
(
    # Variables
    echo word=dog
    echo i=1

    # add the template
    echo "cat << EOF"
    cat template.txt
    echo EOF
) | bash
```
Diskussion
- Die Klammern öffnet eine sub-shell, sein Zweck ist die Gruppe zusammen, alle die generierte Ausgabe
- Innerhalb der sub-shell, die wir generieren, werden alle Deklarationen von Variablen
- Auch in der sub-shell erzeugen wir die cat Befehl mit der HEREDOC -
- Schließlich füttern wir die sub-shell die Ausgabe bash und erzeugen Sie die gewünschte Ausgabe -
- Wenn Sie möchten, leiten Sie diese Ausgabe in eine Datei, ersetzen Sie die Letzte Zeile mit:
```
) | bash > output.txt
```
InformationsquelleAutor der Antwort Hai Vu
1

Können Sie auch bashible (intern verwendet die Bewertung der beschriebenen Methode oben/unten).

Es ist ein Beispiel, das generieren von HTML aus mehreren teilen:

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

InformationsquelleAutor der Antwort Jan Molič

# 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 einstellbar nach Ihren wünschen, in der Produktion verwendet und sollten nicht brechen, die auf jede Eingabe.
Wenn es bricht - lass es mich wissen.

InformationsquelleAutor der Antwort ttt

Hier ist eine bash-Funktion, die bewahrt whitespace:

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

InformationsquelleAutor der Antwort Igor Katson

0

Hier ist eine modifizierte perl script basiert auf ein paar andere Antworten:
```
perl -pe 's/([^\\]|^)\$\{([a-zA-Z_][a-zA-Z_0-9]*)\}/$1.$ENV{$2}/eg' -i template
```
Features (basierend auf meine Bedürfnisse, aber sollte leicht zu ändern):
- Überspringt entgangen parameter-Erweiterungen (z.B. \${VAR}).
- Unterstützt parameter-Erweiterungen der form ${VAR}, nicht aber $VAR.
- Ersetzt ${VAR} mit einem leeren string, wenn es keine VAR envar.
- Unterstützt nur a-z, A-Z, 0-9 und Unterstrich-Zeichen in den Namen (ohne Ziffern an der ersten Stelle).
InformationsquelleAutor der Antwort Kevin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Bearbeiten, Jan 6, 2017

Diskussion