Add translations

docs/platform/workloads/nodejs.mdx

@@ -64,7 +64,7 @@ See our guide on [Running Webservers](../webservers#making-your-app-accessible-v
 
 See our guide on [Running Webservers](../webservers/#managing-your-process-lifecycle) to learn how to manage the process lifecycle of your Node.js application.
 
-## Example application
+## Example applications
 
 ### Express.js
 
@@ -100,7 +100,7 @@ The `--no-daemon` flag in this example is especially important. It tells PM2 to
 
 :::
 
-For this, you need to have PM2 installed in your application environment. You can install it via NPM:
+Furthermore, you need to have PM2 installed in your application environment. You can install it via NPM:
 
 ```shellsession title="SSH shell session"
 $ npm install -g pm2

docs/platform/workloads/python.mdx

@@ -40,7 +40,7 @@ import TabItem from "@theme/TabItem";
 
   </TabItem>
   <TabItem value="api" label="API">
-    To learn how to deploy a Node.js application via the API, read the article ["Starting a Node.js application"](../../../api/howtos/create-nodejs).
+    To learn how to deploy a Python application via the API, read the article ["Starting a Node.js application"](../../../api/howtos/create-nodejs).
   </TabItem>
 </Tabs>
 

docs/platform/workloads/webservers.mdx

@@ -19,7 +19,7 @@ As a prerequisite, you need an mStudio application that contains a webserver, fo
 
 ## Making your app accessible via HTTP
 
-After you have created your webserver application, you can make it accessible via HTTP. Our platform will make sure that the process that you have configured in the previous step will be running at all times.
+After you have created your webserver application, you can make it accessible via HTTP. Our platform will make sure that the process that you have configured as "entrypoint" in the previous step will be running at all times.
 
 :::info
 

i18n/de/code.json

@@ -376,5 +376,56 @@
   "theme.unlistedContent.message": {
     "message": "This page is unlisted. Search engines will not index it, and only users having a direct link can access it.",
     "description": "The unlisted content banner message"
+  },
+  "index.api.title": {
+    "message": "Automate and integrate with our API"
+  },
+  "index.api.body": {
+    "message": "Unsere API ermöglicht es dir, deine mittwald-Produkte und -Services programmatisch zu verwalten. Du kannst sie nutzen, um Aufgaben zu automatisieren, unsere Services in deine eigenen Anwendungen zu integrieren oder völlig neue Anwendungen auf unserer Plattform zu erstellen."
+  },
+  "index.reference.intro": {
+    "message": "Einleitung"
+  },
+  "index.reference.tutorials": {
+    "message": "Wir bieten auch Tutorials und Beispiele, um dir den Einstieg in unsere API zu erleichtern."
+  },
+  "index.reference.tutorials-link": {
+    "message": "Schau sie dir an!"
+  },
+  "index.deploy.title": {
+    "message": "Deployment leicht gemacht"
+  },
+  "index.deploy.body": {
+    "message": "Deploye deine Anwendungen und Services auf unserer Plattform mit Leichtigkeit. Wir unterstützen eine Vielzahl von Programmiersprachen, Frameworks und Datenbanken."
+  },
+  "index.deploy.platform.title": {
+    "message": "Plattform-Features"
+  },
+  "index.deploy.platform.body": {
+    "message": "Unsere Plattform bietet eine Vielzahl von Funktionen, um dir beim Deployment deiner Anwendungen und Services zu helfen:"
+  },
+  "index.deploy.platform.language": {
+    "message": "Laufzeit-Umgebungen"
+  },
+  "index.deploy.platform.databases": {
+    "message": "Datenbanken"
+  },
+  "index.deploy.platform.features": {
+    "message": "Fehlt ein Feature?"
+  },
+  "index.deploy.platform.features-link": {
+    "message": "Hier anfragen!"
+  },
+  "index.deploy.tools.title": {
+    "message": "Tools und Integrationen"
+  },
+  "index.deploy.tools.body": {
+    "message": "Wir bieten eine Vielzahl von Tools, Integrationen und Tutorials, um dir beim Deployment deiner Anwendungen und Services zu helfen:"
+  },
+  "index.deploy.tools.development": {
+    "message": "Lokale Entwicklung"
+  },
+  "index.deploy.tools.deployment-provisioning": {
+    "message": "Deployment und Provisionierung"
   }
 }

i18n/de/docusaurus-plugin-content-docs/current.json

@@ -30,5 +30,13 @@
   "sidebar.tutorialSidebar.category.Deployment guides": {
     "message": "Deployment-Anleitungen",
     "description": "The label for category Deployment guides in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Platform": {
+    "message": "Plattform",
+    "description": "The label for category Platform in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Application workloads": {
+    "message": "Anwendungs-Workloads",
+    "description": "The label for category Application workloads in sidebar tutorialSidebar"
   }
 }

i18n/de/docusaurus-plugin-content-docs/current/platform/databases/mysql.mdx

@@ -0,0 +1,119 @@
+---
+title: MySQL
+sidebar_position: 10
+description: |
+  MySQL ist ein Open-Source-Relationales Datenbankmanagementsystem (RDBMS). Es ist eine beliebte Wahl für Webanwendungen und wird oft in Kombination mit PHP verwendet. Dieser Leitfaden hilft dir, MySQL in deinem mittwald-Space zu verwenden.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+import OperationHint from "@site/src/components/OperationHint";
+
+## Eine MySQL-Datenbank erstellen
+
+<Tabs groupId="access-mode">
+  <TabItem value="gui" label="mStudio UI">
+    Um eine MySQL-Datenbank im mStudio zu erstellen, befolge diese Schritte:
+
+    1. Navigiere zu dem Projekt, in dem du die Datenbank erstellen möchtest.
+    2. Wähle im Seitenmenü den Menüpunkt "Datenbanken".
+    3. Klicke auf den Button "Datenbank erstellen" und wähle "MySQL".
+    4. Gib eine Beschreibung für die Datenbank ein, wähle die gewünschte Version und lege ein Passwort für den Datenbankbenutzer fest.
+
+    Nachdem die Installation abgeschlossen ist, beobachte den Host und den Port in den Details unter Verbindungsinformationen. Du benötigst beides für die Konfiguration deines Systems.
+
+  </TabItem>
+  <TabItem value="cli" label="CLI">
+    Um eine MySQL-Datenbank über die CLI zu erstellen, führe die folgenden Befehle aus:
+
+    ```bash
+    $ mw database mysql create --description "My MySQL database" --version 8.0
+    ```
+
+    Dieser Befehl fordert dich auf, ein Passwort für den Datenbankbenutzer einzugeben. Um die Aufforderung zu überspringen, verwende die Option `--password` (sei vorsichtig, da das Passwort in deiner Shell-History gespeichert wird) oder setze zuerst die Umgebungsvariable `MYSQL_PWD`:
+
+    ```bash
+    $ read -s MYSQL_PWD
+    $ export MYSQL_PWD
+    $ mw database mysql create ...
+    ```
+
+    Es gibt zusätzliche Flags, die du angeben kannst, um zusätzliche Optionen festzulegen:
+
+    - `--character-set` und `--collation` um den [Zeichensatz und die Kollation](https://dev.mysql.com/doc/refman/8.0/en/charset-mysql.html) für die Datenbank festzulegen. Diese sind standardmäßig auf `utf8mb4` und `utf8mb4_unicode_ci` festgelegt. Normalerweise sollte es nur wenige Gründe geben, diese zu ändern, außer bei der Migration von einer vorhandenen Datenbank.
+    - `--user-access-level` erlaubt dir, die Berechtigungen des Datenbankbenutzers einzuschränken. Standardmäßig ist dies `full`, was alle Berechtigungen gewährt. Du kannst auch `readonly` wählen.
+    - `--user-external` erlaubt dir, einen Benutzer zu erstellen, der sich von außerhalb der mittwald-Plattform verbinden kann. Dies ist standardmäßig deaktiviert.
+
+    Nachdem die Installation abgeschlossen ist, verwende den Befehl `mw database mysql get`, um die Verbindungsinformationen zu beobachten.
+
+  </TabItem>
+  <TabItem value="api" label="API">
+
+    <OperationHint tag="Database" operation="database-create-mysql-database" />
+
+  </TabItem>
+</Tabs>
+
+## Betrieb
+
+### Managed Backup und Wiederherstellung
+
+Die mittwald-Cloud-Plattform erstellt in regelmäßigen Abständen automatisch Backups deiner Projekte und ihrer Datenbanken. Du kannst die verfügbaren Backups jederzeit über die mStudio-Benutzeroberfläche oder das [`mw` CLI][cli] einsehen, indem du den Befehl `mw backup list` verwendest. Du kannst auch manuell ein Backup erstellen, indem du den Befehl `mw backup create` ausführst:
+
+```shellsession title="Local shell session"
+$ mw backup create --wait --expires 30d
+```
+
+Um die Inhalte einer einzelnen MySQL-Datenbank wiederherzustellen, kannst du die folgenden Schritte befolgen:
+
+1. Lade ein Backup auf deinen lokalen Rechner herunter:
+
+    ```shellsession title="Local shell session"
+    $ mw backup download <backup-id> --format tar --output backup.tar.gz
+    ```
+
+2. Nachdem du das Backup heruntergeladen hast, kannst du den Inhalt der Datenbank aus dem heruntergeladenen Archiv extrahieren:
+
+    ```shellsession title="Local shell session"
+    $ database_id=<database-id>
+    $ tar xfz backup.tar.gz dbdump-${database_id/_/-}
+    ```
+
+    :::note
+
+    Beachte, dass in den Archivdateien die Datenbank-ID anders geschrieben ist. Während sie normalerweise das Format `mysql_XXXXXX` hat, wird sie im Archiv mit Bindestrichen anstelle von Unterstrichen geschrieben, wie `mysql-XXXXXX`.
+
+    :::
+
+3. Stelle das Backup mit dem Befehl `mw database mysql import` wieder her. Dafür musst du einen SSH-Schlüssel auf deinem lokalen Rechner eingerichtet haben, der auch mit deinem mStudio-Benutzerkonto verknüpft ist.
+
+    ```shellsession title="Local shell session"
+    $ database_id=<database-id>
+    $ mw database mysql import ${database_id} --input dbdump-${database_id/_/-}/*.sql.gz --gzip
+    ```
+
+### Manuelle Sicherung und Wiederherstellung
+
+Du kannst das [`mw` CLI][cli] verwenden, um manuell Backups deiner MySQL-Datenbank zu erstellen (und wiederherzustellen). Als Voraussetzung musst du einen SSH-Schlüssel auf deinem lokalen Rechner eingerichtet haben, der auch mit deinem mStudio-Benutzerkonto verknüpft ist.
+
+Um ein Backup zu erstellen, führe den folgenden Befehl aus:
+
+```shellsession title="Local shell session"
+$ mw database mysql dump <database-id> --output dump.sql.gz --gzip
+```
+
+Ersetze in diesem Befehl `<database-id>` durch die ID der MySQL-Datenbank, die du sichern möchtest. Der `--gzip`-Flag komprimiert die Backup-Datei, was Speicherplatz sparen und die Übertragungszeiten reduzieren kann.
+
+:::tip
+
+Wenn du das Backup mit einem anderen Benutzer erstellen möchtest als dem, mit dem du gerade angemeldet bist, kannst du den `--ssh-user`-Flag verwenden, um einen anderen Benutzer für die SSH-Verbindung anzugeben. Du musst jedoch sicherstellen, dass ein SSH-Schlüssel auf deinem lokalen Rechner für diesen Benutzer eingerichtet ist.
+
+:::
+
+Um ein Backup wiederherzustellen, führe den folgenden Befehl aus:
+
+```shellsession title="Local shell session"
+$ mw database mysql import <database-id> --input dump.sql.gz --gzip
+```
+
+[cli]: /docs/v2/api/sdks/cli

i18n/de/docusaurus-plugin-content-docs/current/platform/databases/opensearch.mdx

@@ -0,0 +1,30 @@
+---
+title: OpenSearch
+sidebar_position: 100
+description: |
+  OpenSearch ist eine von der Community getriebene und quelloffene Suchmaschine, die von Elasticsearch abgezweigt wurde.
+---
+
+import PlanCompatibility from "@site/src/components/PlanCompatibility";
+
+<PlanCompatibility plans={["ps", "ss"]} />
+
+## Was ist OpenSearch?
+
+OpenSearch ist eine von der Community getriebene, quelloffene Suchmaschine, die von Elasticsearch abgezweigt wurde. Es handelt sich um eine verteilte, RESTful Such- und Analyse-Engine, die in der Lage ist, eine wachsende Anzahl von Anwendungsfällen zu lösen. Als Fork von Elasticsearch ist OpenSearch vollständig kompatibel mit Elasticsearch-APIs und -Plugins.
+
+## Eine OpenSearch-Datenbank erstellen
+
+:::important
+
+Wir bieten derzeit keine Self-Service-Option zum Bereitstellen einer OpenSearch-Datenbank an. Um eine OpenSearch-Datenbank zu erstellen, öffne bitte ein Support-Ticket über den Menüpunkt "Search Engines" in der mStudio-Benutzeroberfläche.
+
+:::
+
+## Übliche Anwendungen konfigurieren
+
+:::important[Aufruf zur Mithilfe!]
+
+Dieser Abschnitt ist derzeit leer. Bitte verwende den [Issue-Tracker](https://github.com/mittwald/developer-portal/issues) dieses Projekts, um Dokumentationen für spezifische Integrationen anzufordern. Wenn du selbst Erfahrung mit der Einrichtung von OpenSearch mit gängigen Open-Source-Anwendungen hast, nehmen wir auch gerne [Pull Requests](https://github.com/mittwald/developer-portal) entgegen, um entsprechende Tutorials hinzuzufügen.
+
+:::

i18n/de/docusaurus-plugin-content-docs/current/platform/languages/nodejs.mdx → i18n/de/docusaurus-plugin-content-docs/current/platform/workloads/nodejs.mdx

@@ -1,6 +1,7 @@
 ---
 title: Node.js-Anwendungen verwalten und deployen
 sidebar_label: Node.js
+sidebar_position: 20
 description: Erfahre, wie man Node.js-Anwendungen bereitstellt und verwaltet.
 tags:
   - Node.js
@@ -57,38 +58,67 @@ Da das Deployment deiner Anwendung für den produktiven Einsatz optimiert ist, w
 
 ## Deine Anwendung über HTTP zugänglich machen
 
-Nachdem Du Deine Node.js-Anwendung erstellt hast, kannst Du sie über HTTP zugänglich machen. Unsere Plattform stellt sicher, dass der Prozess, den Du in dem vorherigen Schritt konfiguriert hast, jederzeit ausgeführt wird.
+Wirf einen Blick auf unseren Leitfaden zum [Betrieb von Webservern](../webservers#deine-anwendung-über-http-zugänglich-machen), um zu erfahren, wie du deine Node.js-Anwendung über HTTP zugänglich machen kannst.
 
-:::info
+## Das Verwalten Deines Prozesslebenszyklus
 
-Es besteht die Möglichkeit, dass Deine Anwendung nicht sofort gestartet wird, wenn Du Deine Anwendung _vor_ dem Deployment von Code erstellst. In diesem Fall versucht unsere Automatisierung, Deinen Prozess für eine bestimmte Anzahl von Versuchen zu starten und dann abzubrechen. Wenn Du mit einer Shell in Deiner Hosting-Umgebung verbunden bist, kannst Du das `mittnitectl job status`-Kommando verwenden, um den Status Deines Prozesses zu überprüfen und dann `mittnitectl job start`, um Deinen Prozess zu starten. Siehe den Abschnitt über [das Verwalten Deines Prozesslebenszyklus](#das-verwalten-deines-prozesslebenszyklus) für weitere Informationen.
+Wirf einen Blick auf unseren Leitfaden zum [Betrieb von Webservern](../webservers#das-verwalten-deines-prozesslebenszyklus), um zu erfahren, wie du den Prozesslebenszyklus deiner Node.js-Anwendung verwalten kannst.
 
-:::
+## Beispielanwendungen
 
-Du kannst Deine Anwendung mit dem Internet verbinden, indem Du sie über das mStudio oder die API mit einer Domain verknüpfst. Unsere Plattform kümmert sich darum, den Datenverkehr von dieser Domain zu Deiner Anwendung zu routen, und kümmert sich auch um die TLS-Terminierung, wenn Du ein Zertifikat konfiguriert hast.
+### Express.js
 
-Deine Node.js-Anwendung muss einfach auf einem Port lauschen, der aus der `PORT`-Umgebungsvariablen gelesen werden sollte.
+Der folgende Code-Schnipsel zeigt ein minimales Beispiel einer [Express](https://expressjs.com)-Anwendung, die auf dem Port lauscht, der in der Umgebungsvariable `PORT` angegebenen ist:
 
-:::caution
+```javascript title="app.js"
+const express = require("express");
+const app = express();
+const port = parseInt(process.env.PORT, 10) || 3000;
 
-Bitte mache **KEINE** Annahmen über den Port, auf dem Deine Anwendung hören sollte. Der Port, auf dem Deine Anwendung hören sollte, wird über die `PORT`-Umgebungsvariable bereitgestellt und kann sich jederzeit ändern.
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
 
-:::
+app.listen(port, () => {
+  console.log(`Server running on port ${port}`);
+});
+```
 
-## Das Verwalten Deines Prozesslebenszyklus
+### PM2 mit Live-Reloading
+
+Um fortgeschrittene Funktionen wie einen automatischen Neustart bei Code-Änderungen (nützlich für die Entwicklung) oder Clustering (wenn du alle verfügbaren CPU-Kerne nutzen möchtest) zu aktivieren, kannst du den [PM2](https://pm2.keymetrics.io) Prozessmanager verwenden.
+
+Hierzu musst du eine Node.js-Anwendung mit `pm2` als Einstiegspunkt erstellen (oder alternativ `pm2 start ecosystem.config.js --no-daemon` als `start`-Skript in deiner `package.json`-Datei konfigurieren):
 
-Bei einer Node.js-Anwendung wird der gesamte Lebenszyklus Deines Prozesses innerhalb der Anwendung selbst verwaltet. Innerhalb Deiner Hosting-Umgebung wird Dein Node.js-Prozess vom [mittnite init system](https://github.com/mittwald/mittnite), einem leichten Prozessmanager verwaltet, der für das Starten, Stoppen und Neustarten Deiner Anwendung verantwortlich ist.
+```bash
+$ mw app create node --wait --entrypoint "pm2 start ecosystem.config.js --no-daemon"
+```
+
+:::important
+
+Das Flag `--no-daemon` in diesem Beispiel ist besonders wichtig. Es sagt PM2, dass es im Vordergrund laufen soll. Das ist notwendig, damit die Plattform den Prozess korrekt überwachen kann. **Ohne das `--no-daemon`-Flag wird die Plattform nicht in der Lage sein, deine Anwendung am Laufen zu halten**.
+
+:::
+
+Weiterhin musst du PM2 in deiner Anwendungsumgebung installiert haben. Du kannst es über NPM installieren:
 
-Innerhalb Deiner Hosting-Umgebung kannst Du das `mittnitectl`-Kommando verwenden, um Deine Anwendung zu verwalten:
+```shellsession title="SSH shell session"
+$ npm install -g pm2
+```
 
-- `mittnitectl job start` startet Deine Anwendung
-- `mittnitectl job stop` stoppt Deine Anwendung
-- `mittnitectl job restart` startet Deine Anwendung neu
+Erstelle als nächstes eine ecosystem-Konfigurationsdatei `ecosystem.config.js` in deinem Anwendungsverzeichnis:
 
-Du kannst `mittnitectl` auch verwenden, um den Status Deiner Anwendung anzuzeigen:
+```javascript title="ecosystem.config.js"
+module.exports = {
+  apps: [{
+    name: "test-app",
+    script: "src/server.js",
+    watch: ["src"]
+  }]
+}
+```
 
-- `mittnitectl job status` zeigt den Status Deiner Anwendung an
-- `mittnitectl job logs` zeigt die Logs Deiner Anwendung an
+In diesem Beispiel wird PM2 das `src/server.js`-Skript als Hauptanwendung starten und das `src`-Verzeichnis auf Änderungen überwachen. Wenn Änderungen erkannt werden, wird PM2 die Anwendung automatisch neu starten. Weitere Informationen findest du in der [PM2-Dokumentationsreferenz](https://pm2.keymetrics.io/docs/usage/process-management/).
 
 ## Yarn Plug'n'Play benutzen
 

i18n/de/docusaurus-plugin-content-docs/current/platform/languages/php.mdx → i18n/de/docusaurus-plugin-content-docs/current/platform/workloads/php.mdx

@@ -1,6 +1,7 @@
 ---
 title: PHP-Anwendungen verwalten und deployen
 sidebar_label: PHP
+sidebar_position: 10
 description: Erfahre, wie man PHP-Anwendungen bereitstellt und verwaltet.
 tags:
   - PHP