Bun and OpenJDK

ai/runtime.txt

@@ -0,0 +1,106 @@
+Naše Runtime je docker image, který obsahuje zkompilované různé verze následujících jazyků: python, golang, php, ruby, nodejs, deno, bun, openjdk.
+Jednotlivé aplikace používají různé verze Runtime a běží v docker kontejneru.
+
+V kontejneru běží také SSH daemon a Cron daemon.
+
+Jazyky jsou dostupné v adresáři /opt/techs ve formátu /opt/techs/jazyk-verze, například /opt/techs/python-3.12.0.
+Po aktivaci je primární technologie dostupná v /srv/bin/primary_tech, kde jsou všechny relevantní binární soubory. Tato cesta je i v PATH, ale v supervisordu se musí použít.
+Python používá venv v /srv/venv, který se vytváří automaticky pomocí python z /srv/bin/primary_tech/python a je automaticky aktivovaný. V supervisordu se musí použít /srv/venv/bin/python.
+
+V runtime jde vybrat primární jazyk, který se nastavuje z webového administrátorského rozhraní. Pak je možné aktualizovat na jinou verzi jazyka opět z webového rozhraní nebo pomocí příkazu rosti přes SSH.
+Primární technologie se ve výchozím stavu volí během vytváření aplikace v administraci.
+
+Po spuštení rosti se objeví menu, kde je první položka tech, po odkliknutí se vylistuje seznam podporovaných jazyků a po potvrzení se jazyk změní na vybranou verzi.
+Jazyk v systému nazýváme technologie.
+Kromě jazyka je možné vybrat services kde je možné aktivovat redis nebo memcached. Obojí jde aktivovat i z webové administrace.
+
+Další volbou je možnost změnit crontab. 
+Crontab je umístěn v souboru /srv/conf/crontab a pokud se změní v tomto souboru, je potřeba zavolat příkaz: crontab /srv/conf/crontab
+Aby se nastavil i v systému.
+
+Procesy na pozadí jsou spravovány nástrojem supervisord. Ten má konfiguraci v /srv/conf/supervisor.d/.
+V každém kontejneru je Nginx, který se chová jako reverzní proxy k procesu s uživatelským kódem aplikace.
+
+Nginx má svoji konfiguraci v /srv/conf/nginx.d, která vypadá takto:
+server {
+        listen       0.0.0.0:8000;
+        listen       [::]:8000;
+        location / {
+                proxy_pass         http://127.0.0.1:8080/;
+                proxy_redirect     default;
+                proxy_set_header   X-Real-IP  $remote_addr;
+                proxy_set_header   Host       $host;
+        }
+        #location /static/ {
+        #        alias /srv/static/;
+        #}
+}
+
+Po změně konfigurace supervisordu je potřeba zavolat:
+
+supervisorctl reread
+supervisorctl update
+
+Kde reread načte novou konfiguraci a update ji aplikuje.
+
+Změna konfigurace nginxu se dá načíst buď pomocí nginx -s reload nebo supervisorctl restart nginx
+
+Všechny jazyky mají po kontejneru s aplikací výchozí kód, který se nachází v /srv/app.
+Do /srv/app by měl uživatel nahrát i svůj kód. Adresář /srv/app ale není povinný, jen doporučený a
+je do něj nastavena výchozí konfigurace nginxu a supervisordu.
+V souboru /srv/conf/supervisor.d/JAZYK.conf je pak konfigurace k vybrané primární technologii.
+Tady je ukázka pro Python:
+
+[program:app]
+command=/srv/venv/bin/fastapi run calculator/main.py
+directory=/srv/app
+autostart=true
+autorestart=true
+stdout_logfile=/srv/log/python.log
+stdout_logfile_maxbytes=2MB
+stdout_logfile_backups=5
+redirect_stderr=true
+
+Kde se spouští fastapi web server.
+
+Soubor s logem ve výchozím stavu vždy cestu /srv/log/JAZYK.log.
+Nginx je pak v /srv/log/nginx.log
+Logy rotuje sám supervisord.
+
+Tady je příklad pro OpenJDK:
+
+[program:app]
+command=/srv/bin/primary_tech/java /srv/app/app.java
+environment=PATH="/srv/bin/primary_tech:/usr/local/bin:/usr/bin:/bin:/srv/.npm-packages/bin"
+stopasgroup=true
+directory=/srv/app
+process_name=app
+autostart=true
+autorestart=true
+stdout_logfile=/srv/log/openjdk.log
+stdout_logfile_maxbytes=2MB
+stdout_logfile_backups=5
+stdout_capture_maxbytes=2MB
+stdout_events_enabled=false
+redirect_stderr=true
+
+Je možné aktivovat i sekundární technologii pomocí příkazu activate_tech. Ten je pak dostupný
+stejně jako primární, ale prostředí se nezkonfiguruje pro jeho použití. Nenahraje se tedy
+ukázková aplikace a konfigurace.
+Sekundární jazyky umístěný v /srv/bin/active_JAZYK a tyto cesty jsou dostupné v PATH.
+
+Základem pro všechny jazyky je, aby kód aplikace spustil HTTP server na portu 8080. Na portu 8000
+poslouchá Nginx, který požadavky přesměrovává právě na 8080.
+
+Nginx se dá nastavit pro rychlé servírování statického obsahu pomocí:
+location /static/ {
+    alias /srv/static/;
+}
+
+Pro kopírování dat použij rsync.
+SSH přístup do aplikace je ve formátu: ssh -p PORT [email protected]
+Mění se vždy jen PORT, který je možné najít u aplikace v administraci.
+Heslo se nastavuje v administraci. Při vytváření aplikace je možné uploadovat i SSH klíče.
+Vždy uváděj příklad, jak se připojit do aplikace přes SSH.
+
+Golang kód je možné buildovat v CI/CD nebo přímo v kontejneru s aplikací.

docs/cs/apps/bun.md

@@ -0,0 +1,93 @@
+# Aplikace napsaná v Bun
+
+Tento návod vás provede jednotlivými kroky, jak nahrát kód vaší aplikace napsané v Bun do kontejneru na Roští.cz, jak zajistit, aby Nginx správně přesměrovával požadavky, a jak aplikaci spustit.
+
+## 1. Přihlášení do kontejneru s aplikací
+
+Nejdříve se přihlaste do kontejneru s vaší aplikací přes SSH. Port pro připojení naleznete v naší administraci.
+
+```bash
+ssh -p PORT [email protected]
+```
+
+## 2. Nahrání kódu aplikace do kontejneru
+
+Kód aplikace by měl být nahrán do adresáře `/srv/app`. Doporučujeme použít `rsync` pro efektivní kopírování souborů.
+
+```bash
+rsync -avz --delete ./my-bun-app/ [email protected]:/srv/app/
+```
+
+Tímto příkazem nahrajete obsah adresáře `my-bun-app` z vašeho lokálního počítače do adresáře `/srv/app` v kontejneru.
+
+## 3. Zajištění, aby kód aplikace spustil HTTP server na portu 8080
+
+Aby Nginx správně přesměrovával požadavky na vaši aplikaci, musí váš kód spustit HTTP server na portu 8080. Níže je jednoduchý příklad Bun aplikace, která tento požadavek splňuje.
+
+Vytvořte nebo upravte soubor `/srv/app/app.js` a vložte do něj následující kód:
+
+```javascript
+import { serve } from "bun";
+
+serve({
+  port: 8080,
+  fetch(req) {
+    return new Response("Hello World");
+  },
+});
+```
+
+Tento kód zajistí, že aplikace bude naslouchat na portu 8080, což je nezbytné, aby Nginx mohl správně přesměrovat požadavky.
+
+## 4. Konfigurace Nginx pro přesměrování požadavků
+
+Nginx je nakonfigurován tak, aby přesměrovával HTTP požadavky na port 8000 na vaši aplikaci běžící na portu 8080. Výchozí konfigurace Nginx je již nastavena správně, takže není třeba ji měnit, pokud používáte standardní porty.
+
+Pokud jste provedli nějaké změny v konfiguraci Nginx v `/srv/conf/nginx.d/app.conf`, můžete načíst změny pomocí příkazu:
+
+```bash
+nginx -s reload
+```
+
+## 5. Konfigurace Supervisordu pro správu aplikace
+
+Aplikace je spravována pomocí Supervisordu, což je nástroj pro správu procesů. Musíte vytvořit nebo upravit konfiguraci Supervisordu, aby správně spouštěla vaši Bun aplikaci.
+
+Vytvořte nebo upravte soubor `/srv/conf/supervisor.d/bun.conf` s následujícím obsahem:
+
+```ini
+[program:app]
+command=/srv/bin/primary_tech/bun run /srv/app/app.js
+directory=/srv/app
+autostart=true
+autorestart=true
+stdout_logfile=/srv/log/bun.log
+stdout_logfile_maxbytes=2MB
+stdout_logfile_backups=5
+redirect_stderr=true
+```
+
+Tento konfigurační soubor zajistí, že se vaše aplikace automaticky spustí a bude se restartovat v případě výpadku.
+
+## 6. Spuštění a správa aplikace
+
+Po nahrání kódu a konfiguraci Supervisordu je třeba načíst novou konfiguraci a aplikovat ji:
+
+```bash
+supervisorctl reread
+supervisorctl update
+```
+
+Pokud provedete změny v kódu aplikace, musíte aplikaci restartovat, aby se změny projevily:
+
+```bash
+supervisorctl restart app
+```
+
+## 7. Ověření běhu aplikace
+
+Nyní by měla být vaše Bun aplikace spuštěná a dostupná přes Nginx. Můžete ji otestovat návštěvou URL adresy vaší aplikace ve webovém prohlížeči.
+
+Pokud vše funguje správně, měli byste vidět odpověď "Hello World" z ukázkového kódu nebo výstup vašeho kódu.
+
+Tímto je konfigurace a spuštění aplikace napsané v Bun dokončena.

docs/cs/apps/openjdk.md

@@ -0,0 +1,120 @@
+# Aplikace napsaná v Javě/OpenJDK
+
+Tento návod vás provede jednotlivými kroky, jak nahrát kód vaší aplikace napsané v Javě do kontejneru s aplikací, jak zajistit, aby Nginx správně přesměrovával požadavky, a jak aplikaci spustit.
+
+## 1. Přihlášení do kontejneru s aplikací
+
+Nejdříve se přihlaste do kontejneru s vaší aplikací přes SSH. Port pro připojení naleznete v naší administraci.
+
+```bash
+ssh -p PORT [email protected]
+```
+
+## 2. Nahrání kódu aplikace do kontejneru
+
+Kód aplikace by měl být nahrán do adresáře `/srv/app`. Doporučujeme použít `rsync` pro efektivní kopírování souborů.
+
+```bash
+rsync -avz --delete ./my-java-app/ [email protected]:/srv/app/
+```
+
+Tímto příkazem nahrajete obsah adresáře `my-java-app` z vašeho lokálního počítače do adresáře `/srv/app` v kontejneru.
+
+## 3. Zajištění, aby kód aplikace spustil HTTP server na portu 8080
+
+Aby Nginx správně přesměrovával požadavky na vaši aplikaci, musí váš kód spustit HTTP server na portu 8080. Níže je jednoduchý příklad Java aplikace, která tento požadavek splňuje.
+
+Vytvořte nebo upravte soubor `/srv/app/App.java` a vložte do něj následující kód:
+
+```java
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpExchange;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+
+public class App {
+    public static void main(String[] args) throws IOException {
+        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
+        server.createContext("/", new MyHandler());
+        server.setExecutor(null); // creates a default executor
+        server.start();
+    }
+
+    static class MyHandler implements HttpHandler {
+        public void handle(HttpExchange t) throws IOException {
+            String response = "Hello World";
+            t.sendResponseHeaders(200, response.length());
+            OutputStream os = t.getResponseBody();
+            os.write(response.getBytes());
+            os.close();
+        }
+    }
+}
+```
+
+Tento kód zajistí, že aplikace bude naslouchat na portu 8080, což je nezbytné, aby Nginx mohl správně přesměrovat požadavky.
+
+## 4. Kompilace kódu aplikace
+
+Před spuštěním aplikace je třeba ji zkompilovat. Připojte se k aplikaci přes SSH a spusťte následující příkaz:
+
+```bash
+javac /srv/app/App.java -d /srv/app/
+```
+
+Tímto příkazem zkompilujete Java soubor `App.java` a výsledný `.class` soubor bude uložen do stejného adresáře.
+
+## 5. Konfigurace Nginx pro přesměrování požadavků
+
+Nginx je nakonfigurován tak, aby přesměrovával HTTP požadavky na port 8000 na vaši aplikaci běžící na portu 8080. Výchozí konfigurace Nginx je již nastavena správně, takže není třeba ji měnit, pokud používáte standardní porty.
+
+Pokud jste provedli nějaké změny v konfiguraci Nginx v `/srv/conf/nginx.d/app.conf`, můžete načíst změny pomocí příkazu:
+
+```bash
+nginx -s reload
+```
+
+## 6. Konfigurace Supervisordu pro správu aplikace
+
+Aplikace je spravována pomocí Supervisordu, což je nástroj pro správu procesů. Musíte vytvořit nebo upravit konfiguraci Supervisordu, aby správně spouštěla vaši Java aplikaci.
+
+Vytvořte nebo upravte soubor `/srv/conf/supervisor.d/openjdk.conf` s následujícím obsahem:
+
+```ini
+[program:app]
+command=/srv/bin/primary_tech/java App
+directory=/srv/app
+autostart=true
+autorestart=true
+stdout_logfile=/srv/log/openjdk.log
+stdout_logfile_maxbytes=2MB
+stdout_logfile_backups=5
+redirect_stderr=true
+```
+
+Tento konfigurační soubor zajistí, že se vaše aplikace automaticky spustí a bude se restartovat v případě výpadku.
+
+## 7. Spuštění a správa aplikace
+
+Po nahrání kódu a konfiguraci Supervisordu je třeba načíst novou konfiguraci a aplikovat ji:
+
+```bash
+supervisorctl reread
+supervisorctl update
+```
+
+Pokud provedete změny v kódu aplikace, musíte aplikaci restartovat, aby se změny projevily:
+
+```bash
+supervisorctl restart app
+```
+
+## 8. Ověření běhu aplikace
+
+Nyní by měla být vaše Java aplikace spuštěná a dostupná přes Nginx. Můžete ji otestovat návštěvou URL adresy vaší aplikace ve webovém prohlížeči.
+
+Pokud vše funguje správně, měli byste vidět odpověď "Hello World" z ukázkového kódu nebo výstup vašeho kódu.
+
+Tímto je konfigurace a spuštění aplikace napsané v Javě na Roští.cz dokončena.

docs/cs/runtime.md

@@ -16,3 +16,5 @@ To nás přivádí k aktualizaci, která se liší podle jednotlivých technolog
 * [Deno](apps/deno.md)
 * [Ruby](apps/ruby.md)
 * [Golang](apps/golang.md)
+* [Bun](cs/apps/bun.md)
+* [OpenJDK](cs/apps/openjdk.md)

docs/index.md

@@ -25,6 +25,8 @@ Snažili jsme se přímočaře popsat, jak Roští funguje a jak tam nasadit va
 * [Node.js](cs/apps/nodejs.md)
 * [Deno](cs/apps/deno.md)
 * [Golang](cs/apps/golang.md)
+* [Bun](cs/apps/bun.md)
+* [OpenJDK](cs/apps/openjdk.md)
 <!-- * [Ruby](apps/ruby.md) -->
 
 ## Frameworky a další nástroje

mkdocs.yml

@@ -14,6 +14,8 @@ nav:
         - Node.js: cs/apps/nodejs.md
         - Deno: cs/apps/deno.md
         - Golang: cs/apps/golang.md
+        - Bun: cs/apps/bun.md
+        - Java/OpenJDK: cs/apps/openjdk.md
     - "Frameworky a nástroje":
         - "Laravel": cs/frameworks/laravel.md
         - "WordPress": cs/frameworks/wordpress.md