Instalacja platformy Camunda BPMN wersji 8

Camundę można uruchomić jako klaster Dokera ale wykorzystywanie Dokera w Windows dla Camundy na produkcji nie jest zalecane przez producenta oprogramowania; taka instalacja tylko w celach testowych. Camunda zaleca użycie Kubernetes

Różnice między klastrami Docker a klastrami Kubernetes:

  1. Cel i Zastosowanie:

    • Klastry Docker: Służą do uruchamiania i zarządzania pojedynczymi kontenerami. Idealne dla prostych aplikacji.
    • Klastry Kubernetes: Oferują zaawansowane zarządzanie kontenerami w dużych, złożonych aplikacjach. Umożliwiają automatyzację i orkiestrację.

  2. Architektura:

    • Klastry Docker: Zazwyczaj działają na jednym hoście; mogą korzystać z Docker Swarm dla podstawowej orkiestracji.
    • Klastry Kubernetes: Składają się z węzła master i węzłów roboczych. Mają złożoną architekturę z różnymi komponentami.

  3. Zarządzanie Zasobami:

    • Klastry Docker: Ręczne zarządzanie kontenerami, bez automatycznego monitorowania.
    • Klastry Kubernetes: Automatyczne zarządzanie stanem aplikacji, samodzielne monitorowanie i działania naprawcze.

  4. Funkcjonalność:

    • Klastry Docker: Podstawowe funkcje uruchamiania i zarządzania kontenerami.
    • Klastry Kubernetes: Zaawansowane funkcje, takie jak automatyczne skalowanie, aktualizacje bez przestojów i integracja z CI/CD.

Tworzymy klaster Kubernetes w kontenerze Dokera

Pobranie Kind

W tym celu wykorzystamy Kind. Kind (Kubernetes IN Docker) to narzędzie open-source, które umożliwia uruchamianie klastrów Kubernetes lokalnie w kontenerach Docker. Jest zaprojektowane głównie dla deweloperów i testerów, którzy potrzebują lekkiego i łatwego w zarządzaniu środowiska Kubernetes do celów testowych i deweloperskich.

Kluczowe cechy Kind:

  1. Klastry Kubernetes w Dockerze: Uruchamia całe klastry Kubernetes wewnątrz kontenerów Docker, co pozwala na szybkie tworzenie i usuwanie klastrów.
  2. Przyjazne dla deweloperów: Idealne do testowania aplikacji Kubernetes, Helm Charts oraz eksperymentowania z funkcjami Kubernetes bez konieczności posiadania pełnej infrastruktury.
  3. Zgodność z Kubernetes: Klastry utworzone za pomocą Kind są zgodne z oficjalnymi specyfikacjami Kubernetes, co umożliwia realistyczne testowanie.
  4. Łatwa instalacja: Wymaga jedynie Dockera i Kind, a tworzenie i zarządzanie klastrami odbywa się za pomocą prostych poleceń, takich jak kind create cluster.

Pobieramy Kind ze strony https://kind.sigs.k8s.io. Jeśli planujesz używać tego polecenia często, dodaj je do 'Path' Windows.

Tworzymy klaster w Dokerze

By rozpocząc ten etap musisz oczywiście mieć zainstalowany Docker w systemie - pobierasz oprogramowanie Docker Desktop ze strony docker.com. Być może wolisz wykorzystać do tego celu Hyper-V; Docker nie jest jedynym możliwym środowiskiem klastrów Kubernetes. Tworzymy klaster w Dokerze ktora bedzie domem dla naszych modułów Camundy:

.\kind.exe create cluster --name camunda-platform-local

W rezultacie wykonania tego polecenia zobaczysz odpowiedz podobną do tej poniżej

PS C:\temp> .\kind.exe create cluster --name camunda-platform-local
Creating cluster "camunda-platform-local" ...
 ✓ Ensuring node image (kindest/node:v1.31.0) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
Set kubectl context to "kind-camunda-platform-local"
You can now use your cluster with:

kubectl cluster-info --context kind-camunda-platform-local

Thanks for using kind! 😊

Pobieramy i instalujemy moduły Camundy

Architektura aplikacji

Camuda nie w wersji enterprise posiada cztery podstawowe komponenty:

Zeebe - silnik platformy BPMN

Operate - moduł do zarządzania procesami

Connectors - integracja z zewnętrznymi systemami i komunikacja

Tasklist - interfejs uzytkownika do zarzadzania zadaniami i wykonywania zadań

Następnymi dwoma modułami które są możliwe do instalacji są Identity i Keycloack. Identity odpowiada za zarządzanie uprawnieniami w systemie. Keycloack (https://www.keycloak.org/) to Open Source Identity and Access Management w którym przechowywane są konta użytkowników lub jest mostem pomiędzy innymi bazami użytkowników którzy logują się do Camunda. Czyli: Camunda [tasklist, operate] - Camunda Identity - Keycloack.

Jeśli chcesz zarządzać użytkownikami i ich uprawnieniami w Camunda, musisz mieć zainstalowany Keycloack (+ Camunda Identity).

Dodatkowe dwa systemy które są instalowane i są niezbędne dla działania Camundy to Elasticsearch [baza danych Camundy] i PostgreSQL [wymagana przez Keycloack].

Moduły takie jak Optimize i Web Modeler są dostępne tylko w płatnej wersji. To co bedzie finalnie zainstalowane jest zdefiniowane w pliku konfiguracyjnym instalacji (poniżej).

Jak widzisz fruwa tego całkiem sporo.

Helm - menedżer pakietów dla Kubernetes

Helm to menedżer pakietów dla Kubernetes, który upraszcza instalację, aktualizację i zarządzanie aplikacjami w klastrze. Oto jego kluczowe funkcje w skrócie:

  1. Zarządzanie Aplikacjami:

    • Umożliwia łatwe instalowanie i aktualizowanie aplikacji w Kubernetes.

  2. Pakowanie Aplikacji:

    • Aplikacje są opakowane w „charts”, które zawierają manifesty i pliki konfiguracyjne.

  3. Konfiguracja:

    • Pozwala na dynamiczne dostosowywanie parametrów aplikacji, oddzielając definicję od konfiguracji.

  4. Zarządzanie Wersjami:

    • Przechowuje historię wersji zainstalowanych aplikacji, co umożliwia łatwe cofanie zmian.

Helm ułatwia zarządzanie aplikacjami w Kubernetes, przyspieszając proces wdrażania i aktualizacji. Możesz pobrać najnowszy Helm ze strony https://helm.sh/docs/intro/install/

Pobieramy oprogramowanie Camunda

Pierwszym krokiem jest zbudowanie pliku konfiguracyjnego instalacji yaml ktory wkaże Helm jakie pakiety zainstalować z jakimi zmiennymi/ustawieniami. Przykładowy plik:

global:
  identity:
    auth:
      # Enable the Identity authentication for local development
      enabled: true

# Enable identity as part of the Camunda core
identity:
  keycloak:
    clientSecret: some_secret
    url: http://camunda-platform-keycloak:80/auth
    realm: camunda-platform
    auth-server-url: http://localhost:8080/auth
    # https://hub.docker.com/r/bitnami/keycloak/tags
    image:
      repository: bitnami/keycloak
      tag: 22.0.5
    postgresql:
      # https://hub.docker.com/r/bitnami/postgresql/tags
      image:
        repository: bitnami/postgresql
        tag: 15.5.0

# Disable keycloak
identityKeycloak:
  enabled: true

optimize:
  enabled: false

# Reduce for Zeebe and Gateway the configured replicas and with that the required resources
# to get it running locally
zeebe:
  clusterSize: 1
  partitionCount: 1
  replicationFactor: 1
  pvcSize: 10Gi

zeebeGateway:
  replicas: 1

connectors:
  enabled: true
  inbound:
    mode: disabled

elasticsearch:
  master:
    replicaCount: 1
    # Request smaller persistent volumes.
    persistence:
      size: 15Gi

Pobieramy informacje z repozytorium helm.camunda.io o zasobach i konfiguracji pakietow:

helm repo add camunda https://helm.camunda.io
helm repo update

Pobieramy pakiety i instalujemy je:

helm install camunda-platform camunda/camunda-platform -f C:\Katalog\camunda-platform.yaml

W efekcie zobaczysz na ekranie:

NAME: camunda
LAST DEPLOYED: Thu Sep 26 16:51:34 2024
NAMESPACE: default
STATUS: deployed
REVISION: 1
NOTES:
# (camunda-platform - 10.4.0)

 ######     ###    ##     ## ##     ## ##    ## ########     ###
##    ##   ## ##   ###   ### ##     ## ###   ## ##     ##   ## ##
##        ##   ##  #### #### ##     ## ####  ## ##     ##  ##   ##
##       ##     ## ## ### ## ##     ## ## ## ## ##     ## ##     ##
##       ######### ##     ## ##     ## ##  #### ##     ## #########
##    ## ##     ## ##     ## ##     ## ##   ### ##     ## ##     ##
 ######  ##     ## ##     ##  #######  ##    ## ########  ##     ##

###################################################################

## Installed Services:

- Console:
  - Enabled: false
- Zeebe:
  - Enabled: true
  - Docker Image used for Zeebe: camunda/zeebe:8.5.3
  - Zeebe Cluster Name: "camunda-zeebe"
  - Prometheus ServiceMonitor Enabled: false
- Operate:
  - Enabled: true
  - Docker Image used for Operate: camunda/operate:8.5.4
- Tasklist:
  - Enabled: true
  - Docker Image used for Tasklist: camunda/tasklist:8.5.2
- Optimize:
  - Enabled: true
  - Docker Image used for Optimize: camunda/optimize:8.5.5
- Connectors:
  - Enabled: true
  - Docker Image used for Connectors: camunda/connectors-bundle:8.5.7
- Identity:
  - Enabled: true
  - Docker Image used for Identity: camunda/identity:8.5.5
  - Keycloak: bitnami/keycloak:23.0.7
- Web Modeler:
  - Enabled: false
- Elasticsearch:
  - Enabled: true
  - Docker Image used for Elasticsearch: bitnami/elasticsearch:8.12.2

### Zeebe

The Cluster itself is not exposed as a service which means that you can use `kubectl port-forward` to access the Zeebe cluster from outside Kubernetes:

> kubectl port-forward svc/camunda-zeebe-gateway 26500:26500 -n default
> kubectl port-forward svc/camunda-zeebe-gateway 8088:8080 -n default

Now you can connect your workers and clients to `localhost:26500`
### Connecting to Web apps


As part of the Helm charts, an ingress definition can be deployed, but you require to have an Ingress Controller for that Ingress to be Exposed.
In order to deploy the ingress manifest, set `<service>.ingress.enabled` to `true`. Example: `operate.ingress.enabled=true`

If you don't have an ingress controller you can use `kubectl port-forward` to access the deployed web application from outside the cluster:

Identity:
> kubectl port-forward svc/camunda-identity 8080:80
Operate:
> kubectl port-forward svc/camunda-operate  8081:80
Tasklist:
> kubectl port-forward svc/camunda-tasklist 8082:80
Optimize:
> kubectl port-forward svc/camunda-optimize 8083:80

Connectors:
> kubectl port-forward svc/camunda-connectors 8086:8080


If you want to use different ports for the services, please adjust the related configs in the values file since these ports are used as redirect URLs for Keycloak.

Authentication via Identity/Keycloak is enabled. To login into one of the services please port-forward to Keycloak
as well, otherwise, a login will not be possible. Make sure you use `18080` as a port.

> kubectl port-forward svc/camunda-keycloak 18080:80

Now you can point your browser to one of the service's login pages. Example: http://localhost:8081 for Operate.

Default user and password: "demo/demo"


## Console configuration

- name: camunda
  namespace: default
  version: 10.4.0
  components:
  - name: Keycloak
    id: keycloak
    version: 23.0.7
    url: http://localhost:18080/auth
  - name: Identity
    id: identity
    version: 8.5.5
    url: http://localhost:8080
    readiness: http://camunda-identity.default:82/actuator/health
    metrics: http://camunda-identity.default:82/actuator/prometheus
  - name: Operate
    id: operate
    version: 8.5.4
    url: http://localhost:8081
    readiness: http://camunda-operate.default:80/actuator/health/readiness
    metrics: http://camunda-operate.default:80/actuator/prometheus
  - name: Optimize
    id: optimize
    version: 8.5.5
    url: http://localhost:8083
    readiness: http://camunda-optimize.default:80/api/readyz
    metrics: http://camunda-optimize.default:8092/actuator/prometheus
  - name: Tasklist
    id: tasklist
    version: 8.5.2
    url: http://localhost:8082
    readiness: http://camunda-tasklist.default:80/actuator/health/readiness
    metrics: http://camunda-tasklist.default:80/actuator/prometheus
  - name: Zeebe Gateway
    id: zeebeGateway
    version: 8.5.3
    urls:
      grpc: http://localhost:26500
      http: http://localhost:8088
    readiness: http://camunda-zeebe-gateway.default:9600/actuator/health/readiness
    metrics: http://camunda-zeebe-gateway.default:9600/actuator/prometheus
  - name: Zeebe
    id: zeebe
    version: 8.5.3
    readiness: http://camunda-zeebe.default:9600/actuator/health/readiness
    metrics: http://camunda-zeebe.default:9600/actuator/prometheus

To istotna informacja bo znajdziesz tam adresy, numery portów i informacje jak należy zrobić przekierowania portów.

W każdej chwili możesz podejrzeć te ustawienia instalacji wpisujac:

helm status camunda

Konfigurowanie zainstalowanej Camundy

Kubectl - zarządzanie Kubernetes

Bedziesz potrzebować Kubectl do zarządzania klastrem Kubernetes właśnie zainstalowanych pakietów Camundy. Oto jego główne funkcje w skrócie:

  1. Zarządzanie Zasobami: Tworzenie, odczyt, aktualizacja i usuwanie zasobów Kubernetes (np. podów, usług, deploymentów).

  2. Monitorowanie: Sprawdzanie statusu zasobów i przeglądanie dzienników kontenerów w celu diagnostyki.

  3. Interakcja z Kontenerami: Uruchamianie poleceń bezpośrednio w kontenerach za pomocą komendy exec.

  4. Zarządzanie Kontekstami: Przełączanie między różnymi klastrami i użytkownikami.

  5. Automatyzacja: Umożliwienie użycia skryptów do automatyzacji zadań w Kubernetes.

Pobierz narzędzie ze strony https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/ i dodaj lokalizację do Path Windows.

Podejrzyj status podów klastra:

kubectl get pods

Jeśli wykonasz to polecenie tuż po uruchomieniu instalacji pakietów za pomocą Help, zobaczysz że pody maja jeden ze statusów:

  • Pending
  • Running
  • Succeeded
  • Failed
  • CrashLoopBackOff
  • Unknown

System Camunda wymaga wielu pakietów do działania i ich instalacja zajmuje całkiem sporo czasu (zależne od prędkości sieci, ilości pamięci, procesora). Docelowo wszystkie pody powinny mieć status 'Running'.

Zmiana konfiguracji i restart kontenera

Jeśli chcesz zmienić konfigurację aplikacji, możesz dokonać zmian w pliku konfiguracji yaml a następnie wykonać polecenia:

kubectl apply -f C:\Katalog\camunda-platform.yaml
kubectl delete pod nazwa_poda

Wraz z usunięciem poda, wszystkie kontenery uruchomione w tym podzie zostaną zatrzymane i zakończą swoje działanie. Jeśli pod jest częścią kontrolera, takiego jak Deployment (jak w naszym przypadku), Kubernetes automatycznie utworzy nowy pod w miejsce usuniętego, z ustawieniami określonymi w pliku.

Podgląd hasła admina

Sprawdzanie jakie jest haslo admina Keycloack ktore zostalo wygenerowane podczas instalacji. Użyj następującego polecenia, aby uzyskać dostęp do kontenera Keycloak:

kubectl exec -it camunda-platform-keycloak-0 -- /bin/sh

By podejrzeć zmienne, w tym wypadku zmienną przechowującą hasło (podczas instalacji) uruchom:

printenv | grep KEYCLOAK

W ten sposób zobaczysz wszystkie zmienne poda zawierające frazę 'KEYCLOACK'. Nasze hasło to 'KEYCLOAK_ADMIN_PASSWORD=3FFc07weJF'.

Jeśli chcesz wyświetlić wszystkie zmienne aplikacji, po prostu wpisz:

printenv

Sprawdzanie IP adresu i portu każdego z podów (aplikacji)

Poniższe polecenie wyświetli informacje o działających podach (aplikacjach), ich IP adresach i portach:

kubectl get pods -o custom-columns=NAME:.metadata.name,STATUS:.status.phase,IP:.status.podIP,PORTS:.spec.containers[*].ports[*].containerPort

Przekierowania z lokalnego hosta do usług w klastrze Kubernetes

Po instalacji musisz przekierować ruch z lokalnych adresów i portów do portów usług w klastrze Kubernetes. Umożliwia ci to dostęp do tych usług z lokalnej maszyny przez adres http://localhost:XXXX

Najlepiej wykonać to w Terminalu Windows; w każdym z kolejno uruchamianych zakładek wpisz:

kubectl port-forward svc/camunda-platform-identity 8080:80 - Identity, http://localhost:8080

kubectl port-forward svc/camunda-platform-keycloak 8089:80 - Keycloack [administracja], http://localhost:8089/auth/admin/

kubectl port-forward svc/camunda-platform-keycloak 18080:80 - Keycloack [obsługa logowań użytkowników]

kubectl port-forward svc/camunda-platform-operate  8081:80 - Operate, http://localhost:8081/

kubectl port-forward svc/camunda-platform-tasklist 8082:80 - Tasklist, http://localhost:8082/

kubectl port-forward svc/camunda-platform-zeebe-gateway 26500:26500 -n default - Zeebe API

kubectl port-forward svc/camunda-platform-zeebe-gateway 8088:8080 -n default - Zeebe API

By nie wykonywać tych poleceń ręcznie możesz np. stworzyć plik .bat i dodac go do harmonogramu zadań:

@echo off
start kubectl port-forward svc/camunda-platform-identity 8080:80
start kubectl port-forward svc/another-service 8081:80
start kubectl port-forward svc/yet-another-service 8082:80

Konfiguracja Realm w Keycloack

Przeprowadź proces konfiguracji Realm i Client w Keycloack wg instrukcji https://docs.camunda.io/docs/self-managed/identity/user-guide/configuration/connect-to-an-existing-keycloak/

Aktualizacja zmiennych

Jeśli niektóre ze zmiennych nie były zdefiniowane w pliku konfiguracyjnym instalacji, możesz dodać je po instalacji

set env deployment/camunda-platform-operate KEYCLOAK_REALM=camunda-platform
deployment.apps/camunda-platform-operate env updated

kubectl set env deployment/camunda-platform-operate IDENTITY_CLIENT_SECRET=some_secret
deployment.apps/camunda-platform-operate env updated

kubectl set env deployment/camunda-platform-identity IDENTITY_CLIENT_SECRET=A5epFRGGbbbOKC8EFcb2Xq1BeOsAJkU