Hinzufügen von Engines zu Clustern

Wenn Sie einem Cluster eine Engine hinzufügen möchten, stellen Sie eine Verbindung zur gemeinsam genutzten Datenbank her. Konfigurieren Sie dann den Lastausgleich, um den Datenverkehr an ihn zu senden.

Vorbereitende Schritte

Richten Sie einen Cluster aus Engines ein, einschließlich einer Lastausgleichsfunktion und einer gemeinsam genutzten Datenbank. Siehe Einrichten von Engine-Clustern.
Jede Engine muss dieselbe Version von IBM® UrbanCode Deploy ausführen.

Informationen zu diesem Vorgang

Sie können dem Cluster beliebig viele Engine-Knoten hinzufügen.

Vorgehensweise

Installieren Sie auf dem neuen Knoten die Engine wie unter Installing engines beschrieben. Geben Sie als öffentliche Adresse des Systems die IP-Adresse der Lastausgleichsfunktion an. Verwenden Sie als Keystone-Server denselben Keystone-Server, den Sie bei der Installation einer einzelnen Engine verwenden würden.
Beenden Sie nach der Installation der Engine die Heat-Services.
- Führen Sie unter Red Hat Enterprise Linux (RHEL) Version 6 die folgenden Befehle aus:
```
cd /etc/init.d
```
```
for s in $(ls openstack*); do service $s stop; done
```
- Führen Sie für eine Engine, die mit IBM UrbanCode Deploy ab Version 6.2.1.1 auf RHEL Version 7 bereitgestellt wurde, den folgenden Befehl aus:
```
/extracted_location/ibm-ucd-patterns-install/engine-install/resources/tools/engine-tools.sh -r
```
  In diesem Befehl ist extracted_location der Speicherort der Installationsdateien. Dieses Beispiel ist aus Gründen der Übersichtlichkeit auf separate Zeilen aufgeteilt, der Befehl muss jedoch in einer einzigen Zeile eingegeben werden.

Wenn Sie eine Engine verwenden, die mit IBM UrbanCode Deploy ab Version 6.2.1.1 bereitgestellt wird, konfigurieren Sie die Engine für den Cluster, indem Sie ein Script ausführen. Das Script konfiguriert die Heat-Engine auf diesem Knoten für die Verwendung der gemeinsamen MariaDB-Datenbank und des gemeinsamen RabbitMQ-Service, die/den Sie für den Cluster von Heat-Engine-Servern installiert haben. Das Script wird mit den Installationsdatenträgern für die Heat-Engine bereitgestellt. Sie können dieses Script nur auf einem Server von Red Hat Enterprise Linux (RHEL) Version 7 ausführen. Führen Sie das Script aus, indem Sie den folgenden Befehl eingeben:

/extracted_location/ibm-ucd-patterns-install/engine-install/resources/tools/ha/add-engine2cluster.sh
-a zulässige_URIs
-d Datenbank-URL
-k Keystone-Host
-r RabbitMQ-Host

In diesem Befehl ist extracted_location der Speicherort der Installationsdateien und Sie müssen einen Wert für jede Option angeben.

Option	Beschreibung
`-a`	Legen Sie die autorisierten Keystone-URIs fest. Trennen Sie die URIs durch Kommas voneinander. Beispiel: `http://erster_Keystone:5000/v3,http://zweiter_Keystone:5000/v2.0`
`-d`	Legen Sie die URL der MariaDB-Datenbank für die Heat-Engine fest. Beispiel: `jdbc:mariadb://heat:heat@engine-database.example.com:3306/heat?charset=utf8`
`-k`	Legen Sie den Keystone-Host fest. Beispiel: `engine-database.example.com`
`-r`	Legen Sie den RabbitMQ-Host fest. Beispiel: `engine-database.example.com`

Wenn Sie eine Engine verwenden, die mit IBM UrbanCode Deploy-Versionen vor 6.2.1.1 bereitgestellt wird, konfigurieren Sie die Engine für den Cluster, indem Sie die folgenden Schritte ausführen. Mit diesen Schritten wird die Heat-Engine auf diesem Knoten für die Verwendung der gemeinsamen MySQL-Datenbank und des gemeinsamen RabbitMQ-Service konfiguriert, die/den Sie für den Cluster von Heat-Engine-Servern installiert haben. Diese Befehle gelten für RHEL-Server von Version 6.
1. Beenden Sie die MySQL-Datenbank und verhindern Sie, dass sie beim Systemstart gestartet wird, indem Sie die folgenden Befehle ausführen:
```
service mysqld stop
```
```
chkconfig mysqld off
```
  Die Engine benötigt diesen Service nicht, weil sie die gemeinsam genutzte Engine-Datenbank verwenden muss. Wenn der Clusterknoten kein MySQL für jeglichen anderen Zweck benötigt, können Sie MySQL vom Clusterknoten deinstallieren.
2. Öffnen Sie die Datei /etc/heat/heat.conf in einem Texteditor.
3. Wenn Sie eine Verbindung zu einer anderen Keystone-Engine als der Standard-Keystone-Engine für die Cloud herstellen, suchen Sie in der Datei /etc/heat/heat.conf die Eigenschaft allowed_auth_uris und fügen Sie die vollständige URL für den Keystone-Server dem Eigenschaftswert hinzu. For example, if the engine connects to clouds at cloud1.example.com and cloud2.example.com, the property might look like the following example:
```
allowed_auth_uris=http://cloud1.example.com:5000/v2.0,http://cloud2.example.com:5002/v2
```
4. Suchen Sie die Eigenschaft sql_connection und ändern Sie sie in die Position der gemeinsam genutzten Engine-Datenbank. Beispiel: Wenn die gemeinsam genutzte Engine-Datenbank den Hostnamen engine-database.example.com aufweist, sieht die Eigenschaft wie folgt aus:
```
sql_connection=mysql://heat:heat@engine-database.example.com:3306/heat?charset=utf8
```
5. Suchen Sie die Eigenschaft auth_host und aktualisieren Sie diese entsprechend, damit auf den Hostnamen der Lastausgleichsfunktion verwiesen wird (siehe folgendes Beispiel):
```
auth_host=ucd-patterns.example.com
```
6. Suchen Sie die Eigenschaft rabbit_host und aktualisieren Sie diese entsprechend, damit auf den Hostnamen der gemeinsam genutzten Engine-Datenbank verwiesen wird (siehe folgendes Beispiel):
```
rabbit_host=engine-database.example.com
```
7. Beenden Sie den RabbitMQ-Service:
```
service rabbitmq-server stop
```
8. Verhindern Sie, dass der RabbitMQ-Service beim Systemstart gestartet wird:
```
chkconfig rabbitmq-server off
```
9. Öffnen Sie die Datei /etc/keystone/keystone.conf in einem Texteditor.
10. Suchen Sie in der Datei /etc/keystone/keystone.conf den Parameter connection und aktualisieren Sie ihn entsprechend, damit die gemeinsam genutzte Engine-Datenbank verwendet wird (siehe folgendes Beispiel):
```
connection=mysql://keystone:keystone@engine-database.example.com:3306/keystone?charset=utf8
```
11. Starten Sie die Heat-Services, indem Sie die folgenden Befehle ausführen:
```
cd /etc/init.d
```
```
for s in $(ls openstack*); do service $s start; done
```
```
for s in $(ls openstack*); do service $s status; done
```
Wenn Sie die Engine mithilfe eines Scripts konfiguriert haben, führen Sie nur für die erste Engine im Cluster die folgenden Schritte durch:
1. Synchronisieren Sie den Keystone-Server und die Heat-Engine-Datenbanken. Führen Sie die folgenden Befehle aus:
```
keystone-manage db_sync
heat-manage db_sync
```
2. Um die OpenStack-Endpunkte für den Engine-Cluster zu initialisieren, führen Sie das Script configure-os-services.sh aus. Führen Sie das Script aus, indem Sie den folgenden Befehl eingeben:
```
/extracted_location/ibm-ucd-patterns-install/engine-install/resources/tools/ha/configure-os-services.sh
```

Konfigurieren Sie die Lastausgleichsfunktion entsprechend, damit Datenverkehr an den folgenden Ports an den neuen Engine-Knoten gesendet wird:

5000
35357
8004
8000
8003

Wenn Sie beispielsweise HAProxy verwenden, weist die Konfigurationsdatei möglicherweise Code auf, der den folgenden Snippets ähnlich ist. Bei diesem Codebeispiel wird angenommen, dass die Engine-Knoten die folgenden Hostnamen haben: engine1.example.com, engine2.example.com und engine3.example.com.

frontend keystone_api
    bind *:5000
    default_backend keystone_api_back

frontend keystone_admin
    bind *:35357
    default_backend keystone_admin_back

frontend heat_api
    bind *:8004
    default_backend heat_api_back

frontend heat_cfn
    bind *:8000
    default_backend heat_cfn_back

frontend heat_cloudwatch
    bind *:8003
    default_backend heat_cloudwatch_back

backend keystone_api_back
    balance     roundrobin
    server      enginenode1 engine1.example.com:5000 check
    server      enginenode2 engine2.example.com:5000 check
    server      enginenode3 engine3.example.com:5000 check
    option      httpchk

backend keystone_admin_back
    balance     roundrobin
    server      enginenode1 engine1.example.com:35357 check
    server      enginenode2 engine2.example.com:35357 check
    server      enginenode3 engine3.example.com:35357 check
    option      httpchk

backend heat_api_back
    balance     roundrobin
    server      enginenode1 engine1.example.com:8004 check
    server      enginenode2 engine2.example.com:8004 check
    server      enginenode3 engine3.example.com:8004 check
    option      httpchk

backend heat_cfn_back
    balance     roundrobin
    server      enginenode1 engine1.example.com:8000 check
    server      enginenode2 engine2.example.com:8000 check
    server      enginenode3 engine3.example.com:8000 check
    option      httpchk

backend heat_cloudwatch_back
    balance     roundrobin
    server      enginenode1 engine1.example.com:8003 check
    server      enginenode2 engine2.example.com:8003 check
    server      enginenode3 engine3.example.com:8003 check
    option      httpchk

Starten Sie den HAProxy-Service neu:
```
service haproxy restart
```
Führen Sie auf dem neuen Engine-Knoten die folgenden Befehle aus, um zu überprüfen, ob die Engine ausgeführt wird:
```
source ˜/clientrc
```
```
heat stack-list
```
```
keystone endpoint-list
```
Die Endpunkte, die mit dem Befehl keystone endpoint-list zurückgegeben werden, müssen auf die Lastausgleichsfunktion und nicht auf den Engine-Knoten verweisen.
Überprüfen Sie, ob die Lastausgleichsfunktion Datenverkehr an den neuen Knoten sendet. Wenn zum Beispiel HAProxy auf einem System mit dem Hostnamen ucd-patterns.example.com installiert wird, können Sie die folgende URL aufrufen, um den Status der Knoten anzuzeigen: http://ucd-patterns.example.com:1936/haproxy?stats

Ergebnisse

Die Engine ist Teil des Clusters.

Feedback