Jan Ulrich Hasecke
2022-06-30 2612805de7de8795c3f9092fc5f93671a8553150
commit | author | age
261280 1 # HSAdmin über Skripte steuern {#kap-hsscript-skript}
JUH 2
3 In `kap-hsadmin-syntax`{.interpreted-text role="numref"} wurde die
4 Option `-f`{.interpreted-text role="option"} erwähnt, die gesetzt werden
5 kann, um HSAdmin eine Datei zu übergeben, in der sich die Befehle
6 befinden. Die Option ermöglicht es, ohne großen Aufwand Skriptdateien zu
7 pflegen, mit denen wiederkehrende Aufgaben bequem erledigt werden
8 können. Dieses Kapitel zeigt, wie Sie die Anlage einer neuen
9 Wordpress-Website mit Hilfe eines solchen Skripts vereinfachen können.
10
11 Bevor Sie die eigentliche Wordpress-Software installiert, müssen mehrere
12 Schritte auf der Hostsharing-Plattform erledigt sein.
13
14 1.  Es existiert ein `Domain-Admin`{.interpreted-text role="role"} bzw.
15     es wird ein neuer Domain-Admin angelegt.
16 2.  Es wird eine Domain erstellt und dem Domain-Admin zugewiesen.
17 3.  Es wird ein `Datenbank-Nutzer`{.interpreted-text role="role"}
18     angelegt.
19 4.  Es wird eine Datenbank angelegt und dem Datenbank-Nutzer zugewiesen.
20
21 Mit der folgenden Skript-Datei kann man diese vier Schritte mit einem
22 Befehl ausführen.
23
24 ``` {.text linenos=""}
25 user.add ({set:{name:'xyz00-domains',comment:'Domain-Admin',password:'!1?2-3aBc',shell:'/bin/bash'}})
26 domain.add ({set:{name:'beispiel.de',user:'xyz00-domains'}})
27 mysqluser.add  ({set:{name:'xyz00_owner',password:'?2?3-4cVg'}})
28 mysqldb.add ({set:{name:'xyz00_abc',owner:'xyz00_owner'}})
29 ```
30
31 In Zeile 1 wird der Domain-Admin erzeugt, in Zeile 2 die Domain
32 `beispiel.de` angelegt, in Zeile 3 der Datenbank-Nutzer und in Zeile 4
33 die Datenbank. Es ist möglich, die Datei lesbarer zu formatieren, indem
34 man jedem Key-Value-Paar eine eigene Zeile zuweist.
35
36 ``` {.text linenos=""}
37 user.add ({set:{
38 name:'xyz00-domains',
39 comment:'Domain-Admin',
40 password:'!1?2-3aBc',
41 shell:'/bin/bash'
42 }})
43 domain.add ({set:{
44 name:'beispiel.de',
45 user:'xyz00-domains'
46 }})
47 mysqluser.add ({set:{
48 name:'xyz00_owner',
49 password:'?2?3-4cVg'
50 }})
51 mysqldb.add ({set:{
52 name:'xyz00_abc',
53 owner:'xyz00_owner'
54 }})
55 ```
56
57 Wenn Sie die Datei unter dem Namen `befehlsskript.txt`{.interpreted-text
58 role="file"} im Verzeichnis des `Paket-Admin`{.interpreted-text
59 role="role"} speichern, können Sie alle Befehle mit einem HSAdmin-Aufruf
60 abarbeiten:
61
62 ``` console
63 xyz00@h50:~$ hsscript -f befehlsskript.txt
64 ```
65
66 Wenn Sie beispielsweise häufig Wordpress-Websites installieren, können
67 Sie für jede Website eine solche Befehlsdatei anlegen und unter einem
68 sinnvollen Namen (z.B. `wordpress-beispiel_de.txt`{.interpreted-text
69 role="file"}) abspeichern.
70
71 ::: admonition
72 Beachten Sie die richtige Reihenfolge
73
74 Bei der Anlage von Benutzern, Datenbanken und Domains ist die im
75 Beispiel gezeigt Reihenfolge einzuhalten. Um eine Domain anzulegen, muss
76 der Domain-Admin bereits existieren. Eine Datenbank kann nur erzeugt
77 werden, wenn der Datenbank-Nutzer bereits angelegt ist.
78
79 Beim Löschen müssen Sie die Reihenfolge umkehren: Datenbank löschen,
80 Datenbank-Nutzer löschen, Domain löschen, Domain-Admin löschen.
81 :::
82
83 Noch bequemer ist es, die notwendigen Benutzer, Domains und Datenbanken
84 mit Hilfe eines ausführlicheren JS-Skripts oder über die Python-API
85 anzulegen.
86
87 ## HSAdmin mit Javascript ansprechen
88
89 Im Folgenden zeigen wir zwei JS-Skripts, die in der Regel im Verzeichnis
90 des `Paket-Admin`{.interpreted-text role="role"} mit dessen
91 Benutzerrechten aufgerufen werden. Mit dem ersten Skript erstellen wir
92 eine Domain und weisen ihr einen eigenen Domain-Admin zu, dessen Name
93 aus dem Namen der Domain abgeleitet wird. Mit dem zweiten Skript
94 erzeugen wir eine Datenbank und einen Datenbank-Nutzer, sodass wir unter
95 der gewünschten Domain zum Beispiel eine PHP-Anwendung wie Wordpress
96 einrichten können.
97
98 ### JS-Skript zur Anlage einer Domain
99
100 Ein Skript, um eine Domain mit einem gesonderten Domain-Admin anzulegen,
101 könnte so aussehen:
102
103 ::: {.literalinclude linenos=""}
104 createdomainandadmin.js
105 :::
106
107 Die Funktion `pwGen()` erzeugt ein achtstelliges Passwort aus einer
108 Reihe von vorgegebenen Zeichen. Empfehlenswert sind längere Passworte.
109 Die Funktion `createDomainAndDomainAdmin(args)` erzeugt die Domain und
110 den Domain-Admin. Der Namen des Domain-Admin ergibt sich aus dem Namen
111 der Domain. Bei einer Domain, die einen Bindestrich enthält, muss dieser
112 durch einen Unterstrich ersetzt werden, da Benutzernamen nur einen
113 Bindestrich enthalten dürfen.
114
115 Das Skript wird im Benutzerverzeichnis des Paket-Admin gespeichert und
116 ausführbar gemacht:
117
118 ``` console
119 xyz00@h50:~$ chmod u+x createdomainandadmin.js
120 ```
121
122 Anschließend können Sie es folgendermaßen aufrufen:
123
124 ``` console
125 xyz00@h50:~$ ./createdomainandadmin.js my-domain.de
126 created domain my-domain.de with domainadmin xyz00-my_domain.de and password slo%haY=
127 ```
128
129 Wenn Sie alle Domains mit einem einzigen Domain-Admin verwalten, können
130 Sie den Benutzernamen des Domain-Admin hart kodieren. Zeile 18 lautet
131 dann:
132
133 ::: {.literalinclude lines="18"}
134 createdomain.js
135 :::
136
137 ### JS-Skript zur Anlage einer Datenbank
138
139 Das Skript zur Anlage einer Datenbank und eines Datenbank-Nutzers sieht
140 ähnlich aus.
141
142 ::: {.literalinclude linenos=""}
143 createuseranddb.js
144 :::
145
146 Die Funktion `createMySQLUserAndDB(args)` erzeugt den Datenbank-Nutzer
147 und die Datenbank. Da sich Datenbank und Datenbank-Nutzer nicht in die
148 Quere kommen, haben sie der Einfachheit halber den gleichen Namen.
149
150 Beim Aufruf des Skripts muss eine Zeichenkette übergeben werden, die
151 Bestandteil der Namen von Datenbank und Datenbank-Nutzer wird.
152
153 ``` console
154 xyz00@h50:~$ ./createuseranddb.js my_domain_wordpress
155 created user and database xyz00_my_domain_wordpress with password 4fo=s3xY
156 ```
157
158 ::: attention
159 ::: title
160 Attention
161 :::
162
163 Merken Sie sich die Passworte, da Sie diese später benötigen. Bei einer
164 Datenbank-Anwendungen müssen Sie bei der Konfiguration den
165 Datenbank-Benutzer und sein Passwort angeben.
166 :::
167
168 ## Nutzung der Python-API {#kap-python-api}
169
170 Sie können HSAdmin auch remote über die Python-API des Programms
171 ansprechen. Das ermöglicht es Ihnen von einem entfernten Rechner aus
172 HSAdmin zu bedienen. Um mit der Python-API zu arbeiten müssen Sie
173 zunächst die Python-Bindings für HSAdmin installieren.
174
175 ### Installation von hs.admin.api
176
177 Wir installieren die Python-Bindings in einer virtuellen
178 Python-Umgebung, sodass wir diese zunächst einrichten und aktivieren.
179
180 ``` console
181 $ python3 -m venv /hsadmin
182 $ . /hsadmin/bin/activate
183 ```
184
185 Anschließend klonen wir die Python-Bindings und installieren sie.
186
187 ``` console
188 $ git clone https://dev.hostsharing.net//r/ansible/hs.admin.api.git
189 $ cd hs.admin.api
190 $ python setup.py install 
191 ```
192
193 Nun steht uns das Modul mit dem Python-Bindings in der virtuellen
194 Umgebung zur Verfügung, sodass wir es in einem Skript importieren
195 können.
196
197 ### Python-Skript
198
199 Um die API in einem Skript nutzen zu können, müssen wir mit folgendem
200 Code ein API-Objekt erzeugen.
201
202 ::: {.literalinclude linenos="" lines="1-9"}
203 createdomain.py
204 :::
205
206 Nun ist es möglich, mit der üblichen Syntax HSAdmin im Skript
207 anzusprechen.
208
209 Mit diesen beiden Befehlen legen wir beispielsweise einen Domain-Admin
210 und eine neue Domain an.
211
212 ::: {.literalinclude lines="11-12"}
213 createdomain.py
214 :::
215
216 Eine Datenbank lässt sich folgendermaßen anlegen.
217
218 ::: {.literalinclude lines="11-12"}
219 createuseranddb.py
220 :::
221
222 Nun wollen wir diese Befehle in ein Skript einbauen, das noch einige
223 andere nützliche Dinge für uns erledigt. Reseller und Webmaster, die
224 viele Anwendungen betreuen, buchen häufig mehrere Pakete bei
225 Hostsharing, sodass sie gerne ein Skript hätten, dem sie auch das Kürzel
226 für das Paket übergeben können, in dem sie eine Domain mit Datenbank
227 einrichten möchten. Außerdem wäre es hilfreich, wenn das Skript dafür
228 sorgt, dass Benutzernamen und Datenbankenname immer nach einem
229 einheitlichen Schema erzeugt werden, sodass die Orientierung leichter
230 fällt. In unserem Beispielskript übergeben wir daher dem Skript drei
231 Argumente:
232
233 1.  das Kürzel für das Paket
234 2.  den Domainnamen
235 3.  eine Projekt-ID
236
237 Die Projekt-ID darf nicht mehr als 10 Zeichen umfassen, da sie zusammen
238 mit dem fünfstelligen Paketkürzel in den Namen für Datenbank und
239 Datenbank-Nutzer verwendet wird. Diese dürfen aber nicht länger als 16
240 Zeichen sein. Als Schema für eine Projekt-ID kommt also beispielsweise
241 eine Kombination aus einer Kundennummer und einer Abkürzung in Frage.
242 Wir verwenden in unserem Beispiel dafür eine dreistellige Kundennummer
243 und die Abkürzung `wp` für Wordpress. Die Elemente trennen wir mit dem
244 Unterstrich, da nur dieser als Namensbestandteil erlaubt ist.
245
246 Wenn wir für den Kunden mit der Kundennummer 23 im Paket `xyz00` eine
247 Domain für einen Wordpress-Blog einrichten möchten, lautet der Aufruf
248 des Skripts folgendermaßen:
249
250 ``` console
251 $ python createall.py xyz00 hs-example.de 023_wp
252 ```
253
254 Der Code des Skripts sieht so aus:
255
256 ::: {.literalinclude linenos=""}
257 createall.py
258 :::
259
260 In den ersten fünf Zeilen importieren wir einige Module bzw. Funktionen,
261 die wir benötigen. In den Zeilen 7 bis 9 lesen wir die übergebenen
262 Argumente aus und speichern die Werte in entsprechenden Variablen.
263
264 Um das API-Objekt zu erzeugen, benötigen wir das Passwort für den
265 übergebenen Paket-Admin. Wir lesen in Zeile 11 das Passwort aus dem
266 verschlüsselten Passwort-Tresor des Kommandozeilenprogramms
267 `pass`{.interpreted-text role="command"} aus und speichern es in der
268 Variablen `pw`. Weitere Informationen zu dem Programm finden Sie auf der
269 Website <https://www.passwordstore.org/>. Sie können natürlich andere
270 Programme wählen, um ein Passwort aus einem Passwort-Tresor auszulesen.
271 Falls Sie nur ein Paket bei Hostsharing verwalten, können Sie das
272 Passwort auch direkt ins Skript eintragen. Aus Sicherheitsgründen
273 sollten Sie dies möglichst vermeiden.
274
275 Anschließend erzeugt das Skript das API-Objekt, wobei es als Credentials
276 den Namen des Paket-Admin und sein Passwort übergibt. Der Namen des
277 Paket-Admin ist identisch mit dem Paket, in dem die Domain angelegt
278 werden soll.
279
280 Danach wird ein Zufallsgenerator definiert, mit die Passworte erzeugt
281 werden, die später benötigt werden. In Zeile 27 und 28 werden die
282 Passworte für den Domain-Admin und den Datenbank-Nutzer erzeugt und in
283 Variablen gespeichert. Direkt anschließend erzeugt das Skript aus den
284 beim Aufruf übergebenen Werten die Namen für den Domain-Admin, den
285 Datenbank-Nutzer und die Datenbank.
286
287 In den Zeilen 33 bis 36 werden der Domain-Admin, die Domain, den
288 Datenbank-Nutzer und die Datenbank angelegt.
289
290 Und zum Schluss gibt das Skript alle Daten aus.
291
292 Idealerweise würde ein solches Skript die neuen Benutzernamen mit den
293 jeweiligen Passworten in den Passwort-Tresor eintragen, sodass dies
294 nicht mit der Hand erledigt werden muss.