Stworzyłem polską wersję KubeKosh — Interaktywne Laboratorium Kubernetes po Polsku

    Daniel Nowak·
    devopsFelietonhomelablinuxserwerTestowanie

    Spis treści

    1. Czym jest KubeKosh?
    2. Dlaczego spolszczenie KubeKosh ma sens?
    3. Architektura projektu — co trzeba było przetłumaczyć?
    4. Krok po kroku: proces spolszczenia interfejsu
    5. Tłumaczenie 85 scenariuszy Kubernetes
    6. Jak uruchomić polską wersję KubeKosh?
    7. Czego nauczyłem się przy forkowania projektu open source?
    8. KubeKosh PL vs oryginał — porównanie
    9. Zasoby i linki

    1. Czym jest KubeKosh?

    KubeKosh to samo-hostowane, interaktywne laboratorium Kubernetes uruchamiane w jednym kontenerze Docker. Projekt stworzył zeborg jako narzędzie do nauki Kubernetes przez praktykę — bez potrzeby posiadania konta w chmurze, zewnętrznego klastra ani dodatkowej infrastruktury.

     
    Sprawdź szczegóły:
     
     
     
     

    Co wyróżnia KubeKosh spośród innych platform do nauki Kubernetes:

    • Prawdziwy klaster K3s działa wewnątrz kontenera Docker — ćwiczenia wykonuje się na żywym klastrze, nie w symulacji
    • Terminal przeglądarkowy oparty na xterm.js z WebSocket PTY — pełny dostęp do powłoki bash z przeglądarki
    • Automatyczna weryfikacja rozwiązań — po wykonaniu zadania klikasz „Uruchom Weryfikację” i dostajesz natychmiastowy feedback
    • Tryb egzaminu z odliczaniem czasu — symuluje warunki egzaminów CKA, CKAD i CKS
    • 85 scenariuszy podzielonych na 4 zestawy: Podstawy Kubernetes, CKA, CKAD i CKS

    Projekt jest dostępny jako pojedynczy obraz Docker, co oznacza, że wystarczy jedna komenda, aby mieć gotowe środowisko do nauki.

    2. Dlaczego spolszczenie KubeKosh ma sens?

    Kubernetes jest technologią globalną, ale bariera językowa wciąż stanowi realny problem dla polskich administratorów, deweloperów i studentów wchodzących w świat konteneryzacji.

    Polska społeczność Kubernetes rośnie

    W Polsce Kubernetes jest używany przez setki firm — od startupów technologicznych, przez banki i ubezpieczycieli, po administrację publiczną. Certyfikacje CKA (Certified Kubernetes Administrator), CKAD (Certified Kubernetes Application Developer) i CKS (Certified Kubernetes Security Specialist) zyskują na popularności jako wymagania w ogłoszeniach o pracę.

    Tymczasem większość dostępnych materiałów edukacyjnych — laboratoriów, kursów i platform ćwiczeniowych — jest dostępna wyłącznie po angielsku. Dla osoby, która uczy się jednocześnie Kubernetes i angielskiego technicznego, podwójna bariera może być zniechęcająca.

    Lokalizacja obniża próg wejścia

    Spolszczenie interfejsu i treści scenariuszy nie oznacza, że komendy kubectl zmienią się w narzędzie_kubernetes — komendy i nazwy zasobów Kubernetes pozostają po angielsku, bo tak wygląda realna praca z klastrem. Zmienia się natomiast:

    • Komunikaty interfejsu — zamiast „Select a scenario” widzisz „Wybierz scenariusz”
    • Opisy zadań — zamiast „Your task: fix the broken deployment” czytasz „Twoje zadanie: napraw niedziałający Deployment”
    • Wskazówki — treść podpowiedzi jest po polsku, ale komendy pozostają oryginalne
    • Wyjaśnienia odpowiedzi MCQ — zrozumienie dlaczego dana odpowiedź jest poprawna staje się łatwiejsze

    To samo podejście stosuje większość polskich uczelni technicznych — studenci uczą się programowania po polsku, ale piszą kod po angielsku.

    3. Architektura projektu — co trzeba było przetłumaczyć?

    Przed przystąpieniem do tłumaczenia konieczne było zrozumienie architektury KubeKosh. Projekt składa się z kilku warstw:

    kubekosh/
├── frontend/src/
│   ├── App.jsx                    # Główna aplikacja React
│   └── components/
│       ├── Header.jsx             # Nagłówek z logo i statusem klastra
│       ├── Sidebar.jsx            # Panel boczny z listą scenariuszy
│       ├── BundleNav.jsx          # Nawigacja zestawów (CKA, CKAD, CKS...)
│       ├── ScenarioPanel.jsx      # Panel treści scenariusza
│       ├── Terminal.jsx           # Terminal przeglądarkowy xterm.js
│       ├── ExamTimer.jsx          # Timer trybu egzaminacyjnego
│       ├── ExamReport.jsx         # Raport po zakończeniu egzaminu
│       └── ExamStartModal.jsx     # Modal startu egzaminu
├── backend/
│   └── server.js                  # Express API + WebSocket PTY
├── scenarios/
│   ├── data/*.json                # 85 plików scenariuszy
│   └── bundles/*.json             # 4 pliki zestawów
└── scripts/
    ├── entrypoint.sh              # Start kontenera
    └── nginx.conf                 # Reverse proxy

    Co tłumaczyć, a czego nie tykać

    Kluczową decyzją było określenie granic tłumaczenia. Zasada była prosta:

    ElementTłumaczyć?Uzasadnienie
    Tekst UI (przyciski, etykiety, statusy)TakPolska UX
    Opisy zadań i wskazówkiTakŁatwiejsze rozumienie
    Odpowiedzi MCQ i wyjaśnieniaTakKluczowe dla nauki
    Komendy kubectlNieRealna praca z klastrem
    Bloki kodu ( )NieMuszą działać bez zmian
    Nazwy zasobów (pod, deployment, namespace)NieTerminologia Kubernetes
    Klucze JSON (pola struktury)NieKod backendu
    Wartości techniczne (correct_option, match)NieLogika aplikacji

    4. Krok po kroku: proces spolszczenia interfejsu

    1. Forkowanie repozytorium

    Pierwszym powinno być sforkowanie oryginalnego projektu i sklonowanie go lokalnie:

    git clone https://github.com/zeborg/kubekosh.git kubekosh-pl
cd kubekosh-pl
git remote remove origin
git init
git checkout -b main

    Niestety się pospieszyłem, jedynie sklonowałem i stworzyłem własny projekt na github. Zachowałem licencję Apache 2.0, informacje o autorze oraz odnośnik do oryginalnego projektu, dlatego nie powinno być problemów licencyjnych związanych z publikacją tłumaczenia. Główną wadą pozostaje brak automatycznego powiązania z oryginalnym repozytorium, przez co przyszłe aktualizacje i synchronizacja zmian będą wymagały ręcznej pracy.

    2. Tłumaczenie komponentów React

    Interfejs użytkownika KubeKosh jest zbudowany w React + Vite. Każdy komponent zawierał teksty wbudowane bezpośrednio w JSX — nie było systemu i18n, więc tłumaczenie polegało na bezpośredniej modyfikacji plików źródłowych.

    Header.jsx — nagłówek aplikacji zawierał tagline, komunikaty o statusie klastra i przyciski akcji:

    jsx

    // Przed:
<span className={styles.tagline}>Interactive Kubernetes Lab</span>
<span>{clusterReady ? 'Cluster Ready' : 'Connecting…'}</span>

// Po:
<span className={styles.tagline}>Interaktywne Laboratorium Kubernetes</span>
<span>{clusterReady ? 'Klaster Gotowy' : 'Łączenie…'}</span>

    Sidebar.jsx — panel boczny z filtrowaniem scenariuszy wymagał przetłumaczenia opcji selectów i etykiet. Ważne było zachowanie wartości technicznych (Easy, Medium, Hard) jako wartości wewnętrznych, zmienił się tylko wyświetlany tekst:

    jsx

    // Mapa trudności dla wyświetlania
const DIFF_PL = { Easy: 'Łatwy', Medium: 'Średni', Hard: 'Trudny' }

// W render:
<option value="Easy">Łatwy</option>
<option value="Medium">Średni</option>
<option value="Hard">Trudny</option>

    ScenarioPanel.jsx — największy komponent, odpowiedzialny za zakładki (Zadanie/Wskazówki/Weryfikacja), wyniki MCQ i komunikaty walidacji. Przykładowo, zakładki generowane dynamicznie:

    jsx

    {t === 'problem' ? ' Zadanie'
  : t === 'hints' ? ` Wskazówki (${scenario.hints?.length || 0})`
  : '✓ Weryfikacja'}

    ExamReport.jsx — raport wyników egzaminu tłumaczył próg zaliczenia i werdykt:

    jsx

    // Przed:
{passed ? ' Passed' : ' Failed'}
<div className={styles.passMark}>Pass mark: 66%</div>

// Po:
{passed ? ' Zaliczono' : ' Niezaliczone'}
<div className={styles.passMark}>Próg zaliczenia: 66%</div>

    Terminal.jsx — komunikaty terminala WebSocket były kluczowe dla doświadczenia użytkownika. Przetłumaczono komunikaty o rozłączeniu i przycisk reconect:

    jsx

    ws.onclose = () => {
  term.write('\r\n\x1b[33m[Rozłączono — kliknij Połącz ponownie]\x1b[0m\r\n')
}

    3. Tłumaczenie zestawów (bundles)

    Pliki scenarios/bundles/*.json zawierają metadane zestawów — nazwy i opisy wyświetlane w BundleNav. Zmiana była prosta:

    json

    // Przed:
{
  "name": "Kubernetes Basics",
  "tagline": "Core concepts for beginners"
}

// Po:
{
  "name": "Podstawy Kubernetes",
  "tagline": "Podstawowe pojęcia dla początkujących"
}

    5. Tłumaczenie 85 scenariuszy Kubernetes

    To był zdecydowanie najbardziej pracochłonny etap. Każdy scenariusz to oddzielny plik JSON o strukturze:

    json

    {
  "id": "broken-deployment",
  "title": "Fix the Broken Deployment",
  "type": "task",
  "difficulty": "Medium",
  "category": "Workloads",
  "weight": 4,
  "description": "## Fix the Broken Deployment\n\nA deployment has been pre-created...",
  "hints": [
    {
      "title": "Inspect the deployment",
      "body": "Start by listing pods...",
      "command": "kubectl get pods -n debug"
    }
  ],
  "validation": {
    "description": "Checks that broken-app has 3 ready replicas",
    "commands": [
      {
        "description": "Deployment 'broken-app' has 3 ready replicas",
        "command": "kubectl get deployment broken-app -n debug ...",
        "expected": "3"
      }
    ]
  }
}

    Wyzwanie: zachowanie spójności JSON i kodu

    Tłumaczenie 85 plików JSON z zachowaniem precyzyjnej granicy między tym co tłumaczyć a czego nie dotykać wymagało systematycznego podejścia. Napisałem skrypt Python, który modyfikował każdy plik według jednolitych zasad:

    • Tłumaczone: title, description (tekst narracyjny, nie bloki kodu), hints[].title, hints[].body, options[].text, explanation, validation.description, validation.commands[].description
    • Niezmieniane: id, type, difficulty, category, hints[].command, wszystkie komendy kubectl, bloki „` w markdown, wartości expected, match, correct_option

    Przykład przetłumaczonego scenariusza

    Tytuł: „Fix the Broken Deployment” → „Debugowanie niedziałającego Deployment”

    Opis przed:

    A deployment has been pre-created in the `debug` namespace but its pods are not running.
Your task: Identify the problem and fix it so that the deployment has all 3 pods in Ready state.

    Opis po:

    Deployment został wcześniej utworzony w przestrzeni nazw `debug`, ale jego pody nie działają.
**Twoje zadanie:** Zidentyfikuj problem i napraw go tak, aby Deployment miał wszystkie 3 pody w stanie Ready.

    Wskazówka przed:

    json

    {
  "title": "Check the events",
  "body": "The Events section in kubectl describe usually tells you exactly what's wrong",
  "command": "kubectl describe pod -n debug"
}

    Wskazówka po:

    json

    {
  "title": "Sprawdź zdarzenia",
  "body": "Sekcja Events w kubectl describe zazwyczaj mówi dokładnie co jest nie tak — szukaj ImagePullBackOff, OOMKilled lub błędów sond.",
  "command": "kubectl describe pod -n debug"
}

    Komenda pozostała bez zmian — tylko ludzki tekst został przetłumaczony.

    Skrypt

    1. Instalacja

    pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

    2. Podstawowe użycie

    # Tłumaczenie wszystkich 85 scenariuszy na polski (in-place, z backupem .bak)
python translate_scenarios.py --scenarios-dir ./scenarios/data

# Do oddzielnego katalogu (bez nadpisywania oryginałów)
python translate_scenarios.py --scenarios-dir ./scenarios/data --output-dir ./scenarios/pl

# Tylko jeden plik (test przed całością)
python translate_scenarios.py --file broken-deployment.json

    3. Inne języki

    python translate_scenarios.py --lang german
python translate_scenarios.py --lang "spanish (Latin America)"
python translate_scenarios.py --lang french

    4. Jeśli coś się przerwie — wznowienie

    python translate_scenarios.py --resume
# Plik .translate_progress.json śledzi co już zostało zrobione

    Co skrypt gwarantuje

    FunkcjaSzczegół
    Walidacja po każdym plikuWykrywa jeśli API zmieniło komendę kubectl, expected_output, match, id, type, difficulty
    Retry x3Jeśli API zwróci błędny JSON lub naruszy walidację, ponawia z opóźnieniem
    Rate limit handlingAutomatyczne czekanie 30/60/90s przy błędzie 429
    Backup .bakPrzed każdym nadpisaniem tworzy plik.json.bak — jeden raz, nie nadpisuje
    Progress trackingPlik .translate_progress.json — wznowienie od miejsca przerwania
    Dry run--dry-run pokazuje tytuły przed→po bez żadnego zapisu
    Równoległość--workers 3 przyspiesza 3x (ostrożnie z rate limits API)

    translate_scenarios.py

    Pokryte tematy po polsku

    Po przetłumaczeniu 85 scenariuszy, polscy użytkownicy mają dostęp do pełnego curriculum Kubernetes po polsku:

    Podstawy Kubernetes (Podstawy): Wdrożenie i ekspozycja Nginx, Skalowanie Deployment, Cofanie wdrożenia, Praca z przestrzeniami nazw, Etykietowanie zasobów, Pobieranie logów kontenera, Wykonywanie komend w podzie, Współdzielony wolumen emptyDir, Generowanie manifestów YAML, Kopiowanie plików do kontenerów, Tworzenie Podów wielokontenerowych, Tworzenie CronJob, Tworzenie jednorazowego Job

    CKA — Administrator Kubernetes: Debugowanie niedziałającego Deployment, Naprawianie CrashLoopBackOff, Naprawianie selektora Service, Izolacja ruchu NetworkPolicy, Trwałe przechowywanie PV i PVC, Dynamiczne tworzenie PVC, RBAC Role i RoleBinding, RBAC ClusterRole, Etykiety węzłów i nodeSelector, Skazy i tolerancje, LimitRange, ResourceQuota, PodDisruptionBudget, PriorityClass, Sonda Liveness, Sonda Readiness, ServiceAccount, Żądania i limity zasobów

    CKS — Bezpieczeństwo Kubernetes: Profile AppArmor, Polityka audytu, Tokeny ServiceAccount, Uprawnienia Linuksa (Capabilities), NetworkPolicy Egress, Domyślna polityka odmawiająca, Niezmienne Sekrety, Wymagania non-root, Kontekst bezpieczeństwa, Pod Security Admission, Profile Seccomp, RuntimeClass, Zabezpieczanie Ingress TLS i wiele więcej

    6. Jak uruchomić polską wersję KubeKosh?

    Polska wersja KubeKosh jest dostępna jako gotowy obraz Docker na Docker Hub. Oczywiście trzeba mieć zainstalowany docker na serwerze (https://docs.docker.com/engine/install). Uruchomienie zajmuje dosłownie kilkanaście sekund:

    Szybki start — jedna komenda

    sudo docker run -d --privileged --name kubekosh -p 7554:80 daniel4777/kubekosh-pl:latest

    Następnie otwórz http://localhost:7554 i poczekaj około 30 sekund na uruchomienie klastra K3s.

    Co oznaczają poszczególne flagi?

    FlagaZnaczenie
    -dUruchom w tle (detached mode)
    --privilegedWymagane przez K3s do dostępu do przestrzeni nazw jądra i cgroups
    --name kubekoshNadaje kontenerowi nazwę dla łatwiejszego zarządzania
    -p 7554:80Mapuje port 80 kontenera na port 7554 hosta

    Zachowywanie postępów

    Domyślnie postępy są tracone po usunięciu kontenera. Aby je zachować:

    sudo docker run -d --privileged --name kubekosh -p 7554:80 \
  -v "$HOME/kubekosh-data:/data" daniel4777/kubekosh-pl:latest

    Postępy są przechowywane w bazie SQLite pod ścieżką /data/progress.db.

    Zarządzanie kontenerem

    # Zatrzymaj (zachowuje dane kontenera)
sudo docker stop kubekosh

# Uruchom ponownie
sudo docker start kubekosh

# Sprawdź logi klastra
sudo docker logs kubekosh

# Usuń całkowicie
sudo docker rm -f kubekosh

    7. Czego nauczyłem się przy forkowania projektu open source?

    Proces spolszczenia KubeKosh był moim pierwszym dużym forkiem projektu open source. Kilka wniosków, które mogą się przydać innym:

    1. Zacznij od pełnego audytu, nie od tłumaczenia

    Zanim zmieniłem pierwszą linię kodu, przejrzałem całą strukturę projektu — każdy komponent React, każdy plik JSON, każdy skrypt. Dopiero po pełnym zrozumieniu architektury wiedziałem co tłumaczyć bezpiecznie, a czego nie dotykać.

    2. Zdefiniuj granicę tłumaczenia jako regułę, nie przypadek

    Bez jasnej reguły „co tłumaczymy, a czego nie” łatwo wpaść w pułapkę: przetłumaczyć komendę kubectl przez przypadek albo pozostawić połowę komunikatów po angielsku. W moim przypadku zasada była prosta: jeśli tekst jest wykonywany przez komputer — nie tłumaczę. Jeśli tekst jest czytany przez człowieka — tłumaczę.

    3. Zachowaj spójność nazewnictwa

    Kubernetes ma ustalony słownik polskich tłumaczeń (częściowo oficjalny, częściowo konwencjonalny). Starałem się stosować konsekwentnie:

    • Deployment — bez tłumaczenia (powszechna praktyka w branży)
    • Pod — bez tłumaczenia
    • Przestrzeń nazw — tłumaczenie namespace
    • Wdrożenie — w opisowym kontekście jako synonim Deployment
    • Skazy — tłumaczenie taints
    • Tolerancje — tłumaczenie tolerations
    • Powinowactwo — tłumaczenie affinity

    4. Przetestuj każdy element interfejsu po tłumaczeniu

    Przy tłumaczeniu komponentów React łatwo o błędy: literówki w polskich znakach (ą, ę, ś, ź…), zbyt długie etykiety, które wylewają się poza przyciski, czy brakujące spacje przy sklejaniu stringów. Każdy przetłumaczony komponent wymagał uruchomienia i wizualnej weryfikacji.

    5. Dokumentacja to część projektu, nie opcja

    README przetłumaczony na język projektu i opisujący dokładną komendę uruchomienia (sudo docker run -d --privileged --name kubekosh -p 7554:80 daniel4777/kubekosh-pl:latest) jest równie ważny co sam kod. Użytkownik, który nie może szybko uruchomić projektu, po prostu przejdzie dalej.

    8. KubeKosh PL vs oryginał — porównanie

    CechaKubeKosh (oryginał)KubeKosh PL (fork)
    Język interfejsuAngielskiPolski
    Język scenariuszyAngielskiPolski
    Język komend kubectlAngielskiAngielski (niezmienione)
    Liczba scenariuszy8585
    ZestawyBasics, CKA, CKAD, CKSPodstawy, Administrator, Deweloper, Bezpieczeństwo
    Tryb egzaminuTakTak
    Weryfikacja automatycznaTakTak
    Terminal przeglądarkowyTakTak
    Docker Hubzeborg/kubekoshdaniel4777/kubekosh-pl
    LicencjaApache 2.0Apache 2.0

    Funkcjonalność jest identyczna — spolszczenie to wyłącznie warstwa prezentacji. Żadna logika aplikacji, żaden scenariusz ani żadna komenda weryfikacyjna nie zostały zmienione.

    9. Zasoby i linki

    Projekt

    Uruchomienie jedną komendą

    sudo docker run -d --privileged --name kubekosh -p 7554:80 daniel4777/kubekosh-pl:latest

    Certyfikacje Kubernetes

    Jeśli KubeKosh PL pomógł Ci w nauce, warto rozważyć oficjalne certyfikacje:

    Inne polskie zasoby o Kubernetes

    Podsumowanie

    Spolszczenie KubeKosh to projekt, który zajął kilka godzin intensywnej pracy, ale wynik jest warty wysiłku. Polska wersja interaktywnego laboratorium Kubernetes obniża barierę wejścia dla tysięcy polskich specjalistów IT, którzy chcą nauczyć się Kubernetes lub przygotować się do egzaminów CKA, CKAD i CKS.

    Jeśli interesujesz się Kubernetes, DevOps lub containeryzacją i chcesz ćwiczyć w języku polskim — KubeKosh PL jest gotowy do użycia. Jedna komenda, żadnych rejestracji, żadnych opłat.

    sudo docker run -d --privileged --name kubekosh -p 7554:80 daniel4777/kubekosh-pl:latest

    Otwórz http://localhost:7554 i zacznij ćwiczyć.

    Artykuł opisuje fork projektu KubeKosh autorstwa zeborg, licencjonowanego na zasadach Apache 2.0. Polska wersja dostępna na GitHub i Docker Hub.

     
    Sprawdź szczegóły:
     
     
     
     

    Promocja na kursy n8n, Terraform i Anisble + AI dla Administratora 800 zł taniej

    Dołącz!
    X