Dies ist das neue *CloudFormation Template Reference Guide*. Bitte aktualisieren Sie Ihre Lesezeichen und Links. Hilfe zu den ersten CloudFormation Schritten finden Sie im [AWS CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# `AWS::CloudFormation::Init`
Verwenden Sie den `AWS::CloudFormation::Init` Typ, um Metadaten auf einer EC2 Amazon-Instance für das `cfn-init` Hilfsskript einzuschließen. Wenn Ihre Vorlage das Skript `cfn-init` aufruft, sucht das Skript nach Ressourcen-Metadaten, die im Metadatenschlüssel `AWS::CloudFormation::Init` verankert sind. Weitere Informationen finden Sie unter [cfn-init](cfn-init.md).
`cfn-init` unterstützt alle Metadatentypen für Linux-Systeme. Es unterstützt die Metadatentypen für Windows mit Bedingungen, die in den folgenden Abschnitten beschrieben werden.
## Syntax
Die Konfiguration ist in Abschnitte unterteilt. Der folgende Vorlagenausschnitt zeigt, wie Sie Metadaten für `cfn-init` an eine EC2 Instance-Ressource innerhalb der Vorlage anhängen können.
Die Metadaten sind in Konfigurationsschlüssel organisiert, die Sie in Konfigurationssätze gruppieren können. Sie können ein Configset angeben, wenn Sie `cfn-init` in Ihrer Vorlage aufrufen. Wenn Sie kein Konfigset angeben, sucht `cfn-init` nach einem einzelnen Konfigurationsschlüssel namens `config`.
**Anmerkung**
Das Hilfsskript `cfn-init` verarbeitet diese Konfigurationsabschnitte in der folgenden Reihenfolge: Pakete, Gruppen, Benutzer, Quellen, Dateien, Befehle und dann Dienste. Wenn Sie eine andere Reihenfolge wünschen, trennen Sie Ihre Abschnitte in verschiedene Konfigurationsschlüssel. Verwenden Sie anschließend einen Konfigurationssatz, der die Reihenfolge angibt, in der die Konfigurationsschlüssel verarbeitet werden sollen.
### JSON
```
"Resources": {
"MyInstance": {
"Type": "AWS::EC2::Instance",
"Metadata" : {
"AWS::CloudFormation::Init" : {
"config" : {
"packages" : {
:
},
"groups" : {
:
},
"users" : {
:
},
"sources" : {
:
},
"files" : {
:
},
"commands" : {
:
},
"services" : {
:
}
}
}
},
"Properties": {
:
}
}
}
```
### YAML
```
Resources:
MyInstance:
Type: AWS::EC2::Instance
Metadata:
AWS::CloudFormation::Init:
config:
packages:
:
groups:
:
users:
:
sources:
:
files:
:
commands:
:
services:
:
Properties:
:
```
**Anmerkung**
Die folgenden Abschnitte enthalten Beispiele für Skripte, die in Unix-ähnlichen Shell-Skriptsprachen wie der Bash geschrieben wurden. Um PowerShell stattdessen Skripts für zu erstellen, stellen Sie sicher, dass Sie mit der PowerShell Sprache vertraut sind. PowerShell Die Syntax unterscheidet sich von Unix-ähnlichen Shells, daher müssen Sie mit der PowerShell Vorgehensweise vertraut sein.
## Konfigurationssätze
Wenn Sie mehr als einen Konfigurationsschlüssel erstellen und `cfn-init` diese in einer bestimmten Reihenfolge verarbeiten lassen möchten, erstellen Sie ein Configset, das die Konfigurationsschlüssel in der gewünschten Reihenfolge enthält.
### Einzelner Konfigurationssatz
Der folgende Vorlagenausschnitt erstellt die Konfigurationssätze `ascending` und `descending`, die jeweils zwei Konfigurationsschlüssel enthalten.
#### JSON
```
"AWS::CloudFormation::Init" : {
"configSets" : {
"ascending" : [ "config1" , "config2" ],
"descending" : [ "config2" , "config1" ]
},
"config1" : {
"commands" : {
"test" : {
"command" : "echo \"$CFNTEST\" > test.txt",
"env" : { "CFNTEST" : "I come from config1." },
"cwd" : "~"
}
}
},
"config2" : {
"commands" : {
"test" : {
"command" : "echo \"$CFNTEST\" > test.txt",
"env" : { "CFNTEST" : "I come from config2" },
"cwd" : "~"
}
}
}
}
```
#### YAML
```
AWS::CloudFormation::Init:
configSets:
ascending:
- "config1"
- "config2"
descending:
- "config2"
- "config1"
config1:
commands:
test:
command: "echo \"$CFNTEST\" > test.txt"
env:
CFNTEST: "I come from config1."
cwd: "~"
config2:
commands:
test:
command: "echo \"$CFNTEST\" > test.txt"
env:
CFNTEST: "I come from config2"
cwd: "~"
```
#### Verwandte `cfn-init`-Aufrufe
Die folgenden Beispielaufrufe von `cfn-init` beziehen sich auf die vorangegangenen Beispielkonfigurationen. Die Beispielaufrufe sind der Übersichtlichkeit halber abgekürzt. Siehe [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) für die vollständige Syntax.
+ Wenn ein Aufruf von `cfn-init` das `ascending`-Konfigurationsset angibt:
```
cfn-init -c ascending
```
Das Skript verarbeitet `config1` und dann `config2` und die Datei `test.txt` würde den Text `I come from config2`enthalten.
+ Wenn ein Aufruf von `cfn-init` das `descending`-Konfigurationsset angibt:
```
cfn-init -c descending
```
Das Skript verarbeitet `config2` und dann `config1` und die Datei `test.txt` würde den Text `I come from config1`enthalten.
### Mehrere Konfigurationssätze
Sie können mehrere Configsets erstellen und eine Reihe von ihnen mit Ihrem Skript `cfn-init` aufrufen. Jeder Konfigurationssatz kann eine Liste von Konfigurationsschlüsseln oder Verweisen auf andere Konfigurationssätze enthalten. Der folgende Vorlagenausschnitt erstellt z. B. drei Konfigurationssätze. Der erste Konfigurationssatz `test1`enthält einen Konfigurationsschlüssel mit dem Namen `1`. Der zweite Konfigurationssatz, `test2`, enthält einen Verweis auf den `test1`-Konfigurationssatz und einen Konfigurationsschlüssel mit dem Namen `2`. Der dritte Konfigurationssatz, „default“, enthält einen Verweis auf den Konfigurationssatz `test2`.
#### JSON
```
"AWS::CloudFormation::Init" : {
"configSets" : {
"test1" : [ "1" ],
"test2" : [ { "ConfigSet" : "test1" }, "2" ],
"default" : [ { "ConfigSet" : "test2" } ]
},
"1" : {
"commands" : {
"test" : {
"command" : "echo \"$MAGIC\" > test.txt",
"env" : { "MAGIC" : "I come from the environment!" },
"cwd" : "~"
}
}
},
"2" : {
"commands" : {
"test" : {
"command" : "echo \"$MAGIC\" >> test.txt",
"env" : { "MAGIC" : "I am test 2!" },
"cwd" : "~"
}
}
}
}
```
#### YAML
```
AWS::CloudFormation::Init:
1:
commands:
test:
command: "echo \"$MAGIC\" > test.txt"
env:
MAGIC: "I come from the environment!"
cwd: "~"
2:
commands:
test:
command: "echo \"$MAGIC\" >> test.txt"
env:
MAGIC: "I am test 2!"
cwd: "~"
configSets:
test1:
- "1"
test2:
- ConfigSet: "test1"
- "2"
default:
- ConfigSet: "test2"
```
#### Verwandte `cfn-init`-Aufrufe
Die folgenden Aufrufe von `cfn-init` beziehen sich auf das im vorangegangenen Template-Schnipsel deklarierte `configSets` . Die Beispielaufrufe sind der Übersichtlichkeit halber abgekürzt. Siehe [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) für die vollständige Syntax.
+ Wenn Sie nur `test1` angeben:
```
cfn-init -c test1
```
`cfn-init` verarbeitet nur den Konfigurationsschlüssel `1` .
+ Wenn Sie nur `test2` angeben:
```
cfn-init -c test2
```
`cfn-init` verarbeitet den Konfigurationsschlüssel `1` und dann den Konfigurationsschlüssel `2`.
+ Wenn Sie den `default`-Konfigurationssatz angeben (oder überhaupt keine Konfigurationssätze):
```
cfn-init -c default
```
Sie erhalten dasselbe Verhalten, das Sie erhalten würden, wenn Sie den Konfigurationssatz `test2` angeben würden.
## Befehle
Sie können die Befehlstaste verwenden, um Befehle auf der Instanz auszuführen. EC2 Die Befehle werden in alphabetischer Reihenfolge nach Name verarbeitet.
| Key (Schlüssel) | Erforderlich | Description |
| --- | --- | --- |
| `command` | Erforderlich | Entweder ein Array oder eine Zeichenfolge, das bzw. die den auszuführenden Befehl angibt. Wenn Sie ein Array verwenden, müssen Sie Leerzeichen kein Escape-Zeichen voranstellen und Befehlsparameter nicht in Anführungszeichen angeben. Verwenden Sie das Array nicht, um mehrere Befehle anzugeben. |
| `env` | Optional | Legt Umgebungsvariablen für den Befehl fest. Diese Eigenschaft überschreibt die vorhandene Umgebung, anstatt sie anzuhängen. |
| `cwd` | Optional | Das Arbeitsverzeichnis. |
| `test` | Optional | Ein Testbefehl, der feststellt, ob `cfn-init` Befehle ausführt, die im Befehlsschlüssel angegeben sind. Wenn der Test erfolgreich ist, führt `cfn-init` die Befehle aus. Das Skript `cfn-init` führt den Test in einem Befehlsinterpreter wie der Bash oder `cmd.exe`aus. Ob ein Test bestanden wird, hängt von dem Beendigungscode ab, den der Interpreter zurückgibt. Bei Linux muss der Testbefehl den Beendigungscode `0` zurückgeben, damit der Test bestanden ist. Bei Windows muss der Testbefehl den %ERRORLEVEL% `0` zurückgeben. |
| `ignoreErrors` | Optional | Ein boolescher Wert, der bestimmt, ob `cfn-init` weiter ausgeführt wird, wenn der im Befehlsschlüssel enthaltene Befehl fehlschlägt (gibt einen Wert ungleich Null zurück). Setzen Sie `true`, wenn Sie möchten, dass `cfn-init` auch dann weiterläuft, wenn der Befehl fehlschlägt. Setzen Sie `false`, wenn Sie möchten, dass `cfn-init` aufhört zu laufen, wenn der Befehl fehlschlägt. Der Standardwert ist `false`. |
| `waitAfterCompletion` | Optional | Nur für Windows-Systeme. Gibt an, wie lange gewartet werden soll (in Sekunden) nachdem ein Befehl abgeschlossen wurde, falls der Befehl einen Neustart verursacht. Der Standardwert ist 60 Sekunden und ein Wert von "für immer" weist `cfn-init` an, das Programm zu beenden und erst nach dem Neustart wieder aufzunehmen. Setzen Sie diesen Wert auf `0`, wenn Sie nicht auf jeden Befehl warten möchten. |
### Beispiel
Mit dem folgenden Beispiel wird der Echo-Befehl aufgerufen, wenn die `~/test.txt`-Datei nicht vorhanden ist.
#### JSON
```
"commands" : {
"test" : {
"command" : "echo \"$MAGIC\" > test.txt",
"env" : { "MAGIC" : "I come from the environment!" },
"cwd" : "~",
"test" : "test ! -e ~/test.txt",
"ignoreErrors" : "false"
},
"test2" : {
"command" : "echo \"$MAGIC2\" > test2.txt",
"env" : { "MAGIC2" : "I come from the environment!" },
"cwd" : "~",
"test" : "test ! -e ~/test2.txt",
"ignoreErrors" : "false"
}
}
```
#### YAML
```
commands:
test:
command: "echo \"$MAGIC\" > test.txt"
env:
MAGIC: "I come from the environment!"
cwd: "~"
test: "test ! -e ~/test.txt"
ignoreErrors: "false"
test2:
command: "echo \"$MAGIC2\" > test2.txt"
env:
MAGIC2: "I come from the environment!"
cwd: "~"
test: "test ! -e ~/test2.txt"
ignoreErrors: "false"
```
## Dateien
Sie können den `files` Schlüssel verwenden, um Dateien auf der EC2 Instanz zu erstellen. Der Inhalt kann entweder in die Vorlage eingebettet sein oder von einer URL abgerufen werden. Die Dateien werden in lexikalischer Reihenfolge auf den Datenträger geschrieben. In der folgenden Tabelle sind die unterstützten Schlüssel aufgeführt.
| Key (Schlüssel) | Description |
| --- | --- |
| `content` | Entweder eine Zeichenfolge oder ein ordnungsgemäß formatiertes JSON-Objekt. Wenn Sie ein JSON-Objekt als Ihren Inhalt verwenden, wird es in eine Datei auf dem Datenträger geschrieben. Intrinsische Funktionen wie `Fn::GetAtt` oder `Ref` werden ausgewertet, bevor das JSON-Objekt auf den Datenträger geschrieben wird. Wenn Sie einen Symlink erstellen, geben Sie das Symlink-Ziel als Inhalt an. Wenn Sie einen Symlink erstellen, ändert das Hilfsprogramm-Skript die Berechtigungen der Zieldatei. Derzeit ist es nicht möglich, einen Symlink zu erstellen, ohne die Berechtigungen der Zieldatei zu ändern. |
| `source` | Eine URL, von der die Datei geladen wird. Diese Option kann nicht mit dem Inhaltsschlüssel angegeben werden. |
| `encoding` | Das Codierungsformat. Wird nur verwendet, wenn der Inhalt eine Zeichenfolge ist. Codierung wird nicht angewendet, wenn Sie eine Quelle verwenden. Zulässige Werte: `plain` \$1 `base64` |
| `group` | Der Name der besitzenden Gruppe für diese Datei. Wird für Windows-Systeme nicht unterstützt. |
| `owner` | Der Name des besitzenden Benutzers für diese Datei. Wird für Windows-Systeme nicht unterstützt. |
| `mode` | Ein sechsstelliger Oktalwert, der für den Modus für diese Datei steht. Wird für Windows-Systeme nicht unterstützt. Verwenden Sie die ersten drei Ziffern für Symlinks und die letzten drei Ziffern für das Einrichten von Berechtigungen. Um einen Symlink zu erstellen, geben Sie **120*xxx*** an, wobei `xxx` die Berechtigungen der Zieldatei definiert. Um Berechtigungen für eine Datei anzugeben, verwenden Sie die letzten drei Ziffern, z. B. **000644**. |
| `authentication` | Der Name einer Authentifizierungsmethode, die verwendet werden soll. Dadurch wird jegliche Standardauthentifizierung außer Kraft gesetzt. Mit dieser Eigenschaft können Sie eine Authentifizierungsmethode auswählen, die Sie mit der [`AWS::CloudFormation::Authentication`](aws-resource-authentication.md)-Ressource definieren. |
| `context` | Gibt einen Kontext für Dateien an, die als [Mustache Vorlagen](https://mustache.github.io/mustache.5.html)verarbeitet werden sollen. Um diesen Schlüssel zu verwenden, müssen Sie zusätzlich zu [https://github.com/defunkt/pystache](https://github.com/defunkt/pystache)auch `aws-cfn-bootstrap` 1.3-11 oder höher installiert haben. |
### Beispiele
Das folgende Beispiel erstellt eine Datei mit dem Namen `setup.mysql` als Teil einer größeren Installation.
#### JSON
```
"files" : {
"/tmp/setup.mysql" : {
"content" : { "Fn::Join" : ["", [
"CREATE DATABASE ", { "Ref" : "DBName" }, ";\n",
"CREATE USER '", { "Ref" : "DBUsername" }, "'@'localhost' IDENTIFIED BY '",
{ "Ref" : "DBPassword" }, "';\n",
"GRANT ALL ON ", { "Ref" : "DBName" }, ".* TO '", { "Ref" : "DBUsername" },
"'@'localhost';\n",
"FLUSH PRIVILEGES;\n"
]]},
"mode" : "000644",
"owner" : "root",
"group" : "root"
}
}
```
#### YAML
```
files:
/tmp/setup.mysql:
content: !Sub |
CREATE DATABASE ${DBName};
CREATE USER '${DBUsername}'@'localhost' IDENTIFIED BY '${DBPassword}';
GRANT ALL ON ${DBName}.* TO '${DBUsername}'@'localhost';
FLUSH PRIVILEGES;
mode: "000644"
owner: "root"
group: "root"
```
Die vollständige Vorlage ist verfügbar unter: [https://s3.amazonaws.com/cloudformation-templates-us-east-1/Drupal\$1Single\$1Instance.template](https://s3.amazonaws.com/cloudformation-templates-us-east-1/Drupal_Single_Instance.template).
Mit dem folgenden Beispiel-Codeausschnitt wird eine Symlink-`/tmp/myfile2.txt` erstellt, die auf die vorhandene Datei `/tmp/myfile1.txt` verweist. Die Berechtigungen der Zieldatei `/tmp/myfile1.txt` werden durch den Moduswert `644` erstellt.
#### JSON
```
"files" : {
"/tmp/myfile2.txt" : {
"content" : "/tmp/myfile1.txt",
"mode" : "120644"
}
}
```
#### YAML
```
files:
/tmp/myfile2.txt:
content: "/tmp/myfile1.txt"
mode: "120644"
```
Mustache-Vorlagen werden in erster Linie zum Erstellen von Konfigurationsdateien verwendet. Sie können beispielsweise eine Konfigurationsdatei in einem S3-Bucket speichern und Refs und aus der Vorlage interpolieren, anstatt sie zu verwenden. GetAtts `Fn::Join` Das folgende Beispiel gibt `Content for test9` bis `/tmp/test9.txt`aus.
#### JSON
```
"files" : {
"/tmp/test9.txt" : {
"content" : "Content for {{name}}",
"context" : { "name" : "test9" }
}
}
```
#### YAML
```
files:
/tmp/test9.txt:
content: "Content for {{name}}"
context:
name: "test9"
```
Beachten Sie beim Arbeiten mit Mustache-Vorlagen Folgendes:
+ Der Kontextschlüssel muss für die zu verarbeitenden Dateien vorhanden sein.
+ Der Kontextschlüssel muss eine Schlüssel-Wert-Zuweisung sein, kann jedoch verschachtelt sein.
+ Sie können Dateien mit Inlineinhalt mithilfe des Inhaltsschlüssels und Remote-Dateien mithilfe des Quellschlüssels verarbeiten.
+ Mustache-Unterstützung hängt von der pystache-Version ab. Version 0.5.2 unterstützt die [Mustache 1.1.2-Spezifikation](https://github.com/mustache/spec/tree/v1.1.2).
## Gruppen
Sie können den Gruppenschlüssel verwenden, um Gruppen zu erstellen und Linux/UNIX Gruppen zuzuweisen. IDs Der Gruppenschlüssel wird für Windows-Systeme nicht unterstützt.
Um eine Gruppe zu erstellen, fügen Sie ein neues Schlüssel-Wert-Paar hinzu, das einer optionalen Gruppen-ID einen neuen Gruppennamen zuordnet. Der Gruppenschlüssel kann einen oder mehrere Gruppennamen enthalten. In der folgenden Tabelle werden die verfügbaren Schlüssel aufgeführt.
| Key (Schlüssel) | Description |
| --- | --- |
| `gid` | Eine Gruppen-ID-Nummer. Wenn eine Gruppen-ID angegeben ist und die Gruppe nach Name bereits vorhanden ist, schlägt die Gruppenerstellung fehl. Wenn eine andere Gruppe die angegebene Gruppen-ID aufweist, lehnt das Betriebssystem die Gruppenerstellung möglicherweise ab. Beispiel: `{ "gid" : "23" }` |
### Beispielausschnitt
Der folgende Codeausschnitt gibt eine Gruppe mit dem Namen `groupOne` an, ohne eine Gruppen-ID zuzuweisen, und eine Gruppe mit dem Namen `groupTwo`, die den Gruppen-ID-Wert `45` angegeben hat.
#### JSON
```
"groups" : {
"groupOne" : {},
"groupTwo" : { "gid" : "45" }
}
```
#### YAML
```
groups:
groupOne: {}
groupTwo:
gid: "45"
```
## Pakete
Sie können den Paketeschlüssel verwenden, um vorkonfigurierte Anwendungen und Komponenten herunterzuladen und zu installieren. Auf Windows-Systemen unterstützt der Paketeschlüssel nur das MSI-Installationsprogramm.
### Unterstützte Paketformate
Das Skript `cfn-init` unterstützt derzeit die folgenden Paketformate: apt, msi, python, rpm, rubygems, yum und Zypper. Pakete werden in der folgenden Reihenfolge verarbeitet: rpmyum/apt/zypper, und dann rubygems und python. Bei rubygems und python gibt es keine Reihenfolge und es ist nicht gewährleistet, dass Pakete innerhalb jedes Paketmanagers in einer Reihenfolge installiert werden.
### Angeben von Versionen
Innerhalb jedes Paketmanagers ist jedes Paket als ein Paketname und eine Liste der Versionen angegeben. Die Version kann eine Zeichenfolge, eine Liste von Versionen oder eine leere Zeichenfolge oder Liste sein. Eine leere Zeichenfolge oder Liste gibt an, dass Sie die neueste Version verwenden möchten. Bei RPM-Manager wird die Version als ein Pfad zu einer Datei auf einem Datenträger oder eine URL angegeben.
Wenn Sie eine Version eines Pakets angeben, versucht `cfn-init`, diese Version zu installieren, auch wenn eine neuere Version des Pakets bereits auf der Instance installiert ist. Einige Paketmanager unterstützen mehrere Versionen, andere wiederum nicht. In der Dokumentation zu Ihrem Paketmanager finden Sie weitere Informationen. Wenn Sie keine Version angeben und bereits eine Version des Pakets installiert ist, installiert das Skript `cfn-init` keine neue Version, sondern geht davon aus, dass Sie die bestehende Version behalten und verwenden möchten.
### Beispielausschnitte
#### RPM, yum, Rubygems und Zypper
Der folgende Codeausschnitt gibt eine Versions-URL für RPM an, fordert die neuesten Versionen von yum und Zypper und Version 0.10.2 von chef von rubygems an:
##### JSON
```
"rpm" : {
"epel" : "http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm"
},
"yum" : {
"httpd" : [],
"php" : [],
"wordpress" : []
},
"rubygems" : {
"chef" : [ "0.10.2" ]
},
"zypper" : {
"git" : []
}
```
##### YAML
```
rpm:
epel: "http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm"
yum:
httpd: []
php: []
wordpress: []
rubygems:
chef:
- "0.10.2"
zypper:
git: []
```
#### MSI-Paket
Der folgende Codeausschnitt gibt eine URL für ein MSI-Paket an:
##### JSON
```
"msi" : {
"awscli" : "https://s3.amazonaws.com/aws-cli/AWSCLI64.msi"
}
```
##### YAML
```
msi:
awscli: "https://s3.amazonaws.com/aws-cli/AWSCLI64.msi"
```
## Dienstleistungen
Sie können den Services-Schlüssel verwenden, um zu definieren, welche Services aktiviert oder deaktiviert werden sollen, wenn die Instance gestartet wird. Amazon Linux 2 Systeme und höher mit `aws-cfn-bootstrap` Version 2.0-29\$1 unterstützen diesen Schlüssel durch die Verwendung von systemd. Andere Linux-Systeme unterstützen diesen Schlüssel mit sysvinit (standardmäßig) oder systemd (durch Hinzufügen der erforderlichen Konfigurationen unten). Windows-Systeme unterstützen diesen Schlüssel über den Windows Service Manager.
Mit dem Schlüssel services können Sie auch Abhängigkeiten von Quellen, Paketen und Dateien angeben, so dass, wenn ein Neustart aufgrund der Installation von Dateien erforderlich ist, `cfn-init` den Neustart des Dienstes übernimmt. Wenn Sie beispielsweise das Apache-HTTP-Server-Paket herunterladen, startet die Paketinstallation während der Stack-Erstellung automatisch den Apache-HTTP-Server. Wenn die Konfiguration des Apache-HTTP Servers allerdings später im Stack-Erstellungsprozess aktualisiert wird, wird die Aktualisierung erst wirksam, wenn der Apache-Server neu gestartet wird. Sie können mithilfe des Services-Schlüssels sicherstellen, dass der Apache-HTTP-Service neu gestartet wird.
In der folgenden Tabelle sind die unterstützten Schlüssel aufgeführt.
| Key (Schlüssel) | Description |
| --- | --- |
| `ensureRunning` | Setzen Sie diese Option auf true, um sicherzustellen, dass der Dienst nach Beendigung von `cfn-init` weiterläuft. Setzen Sie diesen Wert auf false, um sicherzustellen, dass der Dienst nach Beendigung von `cfn-init` nicht mehr läuft. Lassen Sie diesen Schlüssel aus, um keine Änderungen am Servicestatus vorzunehmen. |
| `enabled` | Legen Sie den Wert auf „true“ fest, um sicherzustellen, dass der Service beim Systemstart automatisch gestartet wird. Legen Sie den Wert auf „false“ fest, um sicherzustellen, dass der Service beim Systemstart nicht automatisch gestartet wird. Lassen Sie diesen Schlüssel aus, um keine Änderungen an dieser Eigenschaft vorzunehmen. |
| `files` | Eine Liste von Dateien. Wenn Sie `cfn-init` direkt über den Dateiblock ändern, wird dieser Dienst neu gestartet. |
| Quellen | Eine Liste von Verzeichnissen. Wenn `cfn-init` ein Archiv in eines dieser Verzeichnisse expandiert, wird dieser Dienst neu gestartet. |
| Pakete | Eine Zuordnung von Paketmanager zu einer Liste von Paketnamen. Wenn `cfn-init` eines dieser Pakete installiert oder aktualisiert, wird dieser Dienst neu gestartet. |
| commands | Eine Liste von Befehlsnamen. Wenn `cfn-init` den angegebenen Befehl ausführt, wird dieser Dienst neu gestartet. |
### Beispiele
#### Linux
Der folgende Linux-Ausschnitt konfiguriert die Services wie folgt:
+ Der nginx-Dienst wird neu gestartet, wenn entweder `/etc/nginx/nginx.conf` oder `/var/www/html` von `cfn-init`geändert werden.
+ Der Dienst php-fastcgi wird neu gestartet, wenn `cfn-init` php oder spawn-fcgi mit yum installiert oder aktualisiert.
+ Der sendmail-Service wird mit systemd angehalten und deaktiviert.
##### JSON
```
"services" : {
"sysvinit" : {
"nginx" : {
"enabled" : "true",
"ensureRunning" : "true",
"files" : ["/etc/nginx/nginx.conf"],
"sources" : ["/var/www/html"]
},
"php-fastcgi" : {
"enabled" : "true",
"ensureRunning" : "true",
"packages" : { "yum" : ["php", "spawn-fcgi"] }
}
},
"systemd": {
"sendmail" : {
"enabled" : "false",
"ensureRunning" : "false"
}
}
}
```
##### YAML
```
services:
sysvinit:
nginx:
enabled: "true"
ensureRunning: "true"
files:
- "/etc/nginx/nginx.conf"
sources:
- "/var/www/html"
php-fastcgi:
enabled: "true"
ensureRunning: "true"
packages:
yum:
- "php"
- "spawn-fcgi"
systemd:
sendmail:
enabled: "false"
ensureRunning: "false"
```
Um systemd mit einem Service zu verwenden, muss für den Service eine systemd-Einheitsdatei konfiguriert sein. Die folgende Einheitsdatei ermöglicht es systemd, den `cfn-hup`-Daemon im Mehrbenutzer-Serviceziel zu starten und zu stoppen:
```
[Unit]
Description=cfn-hup daemon
[Service]
ExecStart=/usr/bin/cfn-hup -v
PIDFile=/var/run/cfn-hup.pid
[Install]
WantedBy=multi-user.target
```
Bei dieser Konfiguration wird davon ausgegangen, dass `cfn-hup` unter dem Verzeichnis `/usr/bin` installiert ist. Der tatsächliche Ort, an dem `cfn-hup` installiert ist, kann jedoch auf verschiedenen Plattformen variieren. Sie können diese Konfiguration außer Kraft setzen, indem Sie eine Override-Datei in `/etc/systemd/system/cfn-hup.service.d/override.conf` wie folgt erstellen:
```
# In this example, cfn-hup executable is available under /usr/local/bin
[Service]
ExecStart=
ExecStart=/usr/local/bin/cfn-hup -v
```
#### Windows
Der folgende Windows-Ausschnitt startet den `cfn-hup`-Service, legt ihn auf automatisch fest und startet den Service neu, wenn `cfn-init` die angegebenen Konfigurationsdateien ändert:
##### JSON
```
"services" : {
"windows" : {
"cfn-hup" : {
"enabled" : "true",
"ensureRunning" : "true",
"files" : ["c:\\cfn\\cfn-hup.conf", "c:\\cfn\\hooks.d\\cfn-auto-reloader.conf"]
}
}
}
```
##### YAML
```
services:
windows:
cfn-hup:
enabled: "true"
ensureRunning: "true"
files:
- "c:\\cfn\\cfn-hup.conf"
- "c:\\cfn\\hooks.d\\cfn-auto-reloader.conf"
```
## Quellen
Sie können den Quellschlüssel verwenden, um eine Archivdatei herunterzuladen und sie in ein Zielverzeichnis auf der EC2 Instanz zu entpacken. Dieser Schlüssel wird sowohl für Linux- als auch Windows-Systeme vollständig unterstützt.
**Unterstützte Formate**
Unterstützte Formate sind:
+ `tar`
+ `tar+gzip`
+ `tar+bz2`
+ `zip`
### Beispiele
#### GitHub
Wenn Sie es GitHub als Quellcodeverwaltungssystem verwenden`cfn-init`, können Sie den Quellpaketmechanismus verwenden, um eine bestimmte Version Ihrer Anwendung abzurufen. GitHub ermöglicht es Ihnen, eine ZIP-Datei oder eine TAR-Datei aus einer bestimmten Version über eine URL wie folgt zu erstellen:
```
https://github.com//(zipball|tarball)/
```
Das folgende Beispiel zeigt die Version `main` als `.tar`-Datei an.
##### JSON
```
"sources" : {
"/etc/puppet" : "https://github.com/user1/cfn-demo/tarball/main"
}
```
##### YAML
```
sources:
/etc/puppet: "https://github.com/user1/cfn-demo/tarball/main"
```
#### S3 Bucket
Das folgende Beispiel lädt einen Tarball aus einem S3-Bucket herunter und entpackt ihn in `/etc/myapp`:
**Anmerkung**
Sie können Authentifizierungs-Anmeldeinformationen für eine Quelle verwenden. Sie können jedoch keinen Authentifizierungsschlüssel in den Quellen-Block einfügen. Fügen Sie stattdessen einen Buckets-Schlüssel in Ihren `S3AccessCreds`-Block ein. Für weitere Informationen zu Amazon S3-Authentifizierungs-Anmeldeinformationen siehe [`AWS::CloudFormation::Authentication`](aws-resource-authentication.md).
Ein Beispiel finden Sie in der Vorlage [https://s3.amazonaws.com/cloudformation-templates-us-east-1/SourceAuthS3Bucket\$1](https://s3.amazonaws.com/cloudformation-templates-us-east-1/S3Bucket_SourceAuth.template) .template.
##### JSON
```
"sources" : {
"/etc/myapp" : "https://s3.amazonaws.com/amzn-s3-demo-bucket/myapp.tar.gz"
}
```
##### YAML
```
sources:
/etc/myapp: "https://s3.amazonaws.com/amzn-s3-demo-bucket/myapp.tar.gz"
```
## Benutzer
Sie können den Benutzerschlüssel verwenden, um Benutzer auf der Instanz zu erstellen Linux/UNIX . EC2 Der Schlüssel `users` wird für Windows-Systeme nicht unterstützt.
In der folgenden Tabelle sind die unterstützten Schlüssel aufgeführt.
| Key (Schlüssel) | Description |
| --- | --- |
| `uid` | Eine Benutzer-ID. Der Erstellungsprozess ist nicht erfolgreich, wenn der Benutzername mit einer anderen Benutzer-ID vorhanden ist. Wenn die Benutzer-ID bereits einem vorhandenen Benutzer zugewiesen ist, lehnt das Betriebssystem die Erstellungsanforderung möglicherweise ab. |
| `groups` | Eine Liste von Gruppennamen. Der Benutzer wird jeder Gruppe in der Liste hinzugefügt. |
| `homeDir` | Das Stammverzeichnis des Benutzers. |
### Beispiel
Benutzer werden als nicht interaktive Systembenutzer mit der Shell `/sbin/nologin` erstellt. Dies ist beabsichtigt und kann nicht geändert werden.
#### JSON
```
"users" : {
"myUser" : {
"groups" : ["groupOne", "groupTwo"],
"uid" : "50",
"homeDir" : "/tmp"
}
}
```
#### YAML
```
users:
myUser:
groups:
- "groupOne"
- "groupTwo"
uid: "50"
homeDir: "/tmp"
```