Skip to content

Yusuf-Uzun/Film

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

211 Commits
.extras
.extras
 
 
.github/workflows
.github/workflows
 
 
.vscode
.vscode
 
 
__mocks__
__mocks__
 
 
__tests__
__tests__
 
 
scripts
scripts
 
 
src
src
 
 
.depcheckrc.yml
.depcheckrc.yml
 
 
.dockerignore
.dockerignore
 
 
.editorconfig
.editorconfig
 
 
.eslintignore
.eslintignore
 
 
.eslintrc.yml
.eslintrc.yml
 
 
.gitattributes
.gitattributes
 
 
.gitignore
.gitignore
 
 
.hadolint.yaml
.hadolint.yaml
 
 
.markdownlint.yml
.markdownlint.yml
 
 
.markdownlintignore
.markdownlintignore
 
 
.npmrc
.npmrc
 
 
.prettierignore
.prettierignore
 
 
.prettierrc.yml
.prettierrc.yml
 
 
AUTHORS
AUTHORS
 
 
Dockerfile
Dockerfile
 
 
Jenkinsfile
Jenkinsfile
 
 
README.md
README.md
 
 
ToDo.md
ToDo.md
 
 
Zusammenfassung.md
Zusammenfassung.md
 
 
docker-compose.env
docker-compose.env
 
 
docker-compose.yaml
docker-compose.yaml
 
 
film.sqlite
film.sqlite
 
 
helmfile.yaml
helmfile.yaml
 
 
jest.config.ts
jest.config.ts
 
 
nest-cli.json
nest-cli.json
 
 
package-lock.json
package-lock.json
 
 
package.json
package.json
 
 
port-forward.ps1
port-forward.ps1
 
 
sonar-project.properties
sonar-project.properties
 
 
sonar-scanner.ps1
sonar-scanner.ps1
 
 
tsconfig.build.json
tsconfig.build.json
 
 
tsconfig.json
tsconfig.json
 
 
typedoc.cjs
typedoc.cjs
 
 

Repository files navigation

Hinweise zum Programmierbeispiel

Juergen Zimmermann

Diese Datei ist in Markdown geschrieben und kann mit <Strg><Shift>v in Visual Studio Code leicht gelesen werden. Dazu wird die Extension Markdown Preview Mermaid Support empfohlen, um UML-Diagramme in der Syntax von Mermaid (wie bei PlantUML) visualisieren zu können.

Näheres zu Markdown gibt es z.B. bei Markdown Guide

Nur in den ersten beiden Vorlesungswochen kann es Unterstützung bei Installationsproblemen geben.

Inhalt

Download- und ggf. Upload Geschwindigkeit

In einem Webbrowser kann man z.B. mit der URL https://speed.cloudflare.com die Download- und die Upload-Geschwindigkeit testen.

Alternativ kann man durch das Kommando fast in einer Powershell die aktuelle Download-Geschwindigkeit ermitteln.

Mit der zusätzlichen Option --upload kann zusätzlich die aktuelle Upload-Geschwindigkeit ermittelt werden.

Vorbereitung der Installation

  • Das Beispiel nicht in einem Pfad mit Leerzeichen installieren. Viele Javascript-Bibliotheken werden unter Linux entwickelt und dort benutzt man keine Leerzeichen in Pfaden. Ebenso würde ich das Beispiel nicht auf dem Desktop auspacken bzw. installieren.

  • Bei GitHub oder GitLab registrieren, falls man dort noch nicht registriert ist.

ES Modules (ESM)

ESM ist die gängige Abkürzung für ES Modules, so dass man import und export statt require() aus CommonJS verwenden kann. Die Unterstützung von ESM wurde in Node ab Version 12 begonnen. Außerdem ist es wichtig, das man beim Umstieg auf ESM auch die Unterstützung in ts-node und ts-jest beachtet.

Wenn man ESM verwendet, muss man die eigenen Module z.B. folgendermaßen importieren:

    import { myFunc } from './foo.js';
    import { myClass } from './bar/index.js';

Außerdem gibt es ab Node 17.1 das Node Protocol für den Import von Builtin Modules, z.B.:

    import { resolve } from 'node:path';

Gute Literatur zu ESM gibt es bei:

Unterstützung für ESM ist notwendig in:

  • Node
  • TypeScript
  • ts-node
  • ts-jest: versteht noch nicht die Datei-Endung .mts und beim Import .mjs
  • VS Code
  • Node innerhalb von Jenkins

Eigener Namespace in Kubernetes

Genauso wie in Datenbanksystemen gibt es in Kubernetes keine untergeordneten Namespaces. Vor allem ist es in Kubernetes empfehlenswert für die eigene Software einen neuen Namespace anzulegen und NICHT den Default-Namespace zu benutzen. Das wurde bei der Installation von Kubernetes durch den eigenen Namespace acme bereits erledigt. Außerdem wurde aus Sicherheitsgründen beim defaultmäßigen Service-Account das Feature Automounting deaktiviert und der Kubernetes-Cluster wurde intern defaultmäßig so abgesichert, dass

  • über das Ingress-Gateway keine Requests von anderen Kubernetes-Services zulässig sind
  • über das Egress-Gateway keine Requests an andere Kubernetes-Services zulässig sind.

Relationale Datenbanksysteme

PostgreSQL

Docker Compose für PostgreSQL und pgadmin

Wenn man den eigenen Microservice direkt mit Windows laufen lässt, kann man PostgreSQL und das Administrationswerkzeug pgadmin einfach mit Docker Compose starten und später auch herunterfahren.

❗ Vor dem 1. Start von PostgreSQL muss man in docker-compose.yaml im Verzeichnis .extras\postgres die Zeile mit dem (eingeschränkten) Linux-User "postgres:postgres" auskommentieren, damit die Initialisierung von PostgreSQL als Linux-User root ausgeführt werden kann. Danach kopiert man die Skripte create-db-film.sh und create-db-film.sql aus dem Verzeichnis .extras\postgres\sql nach C:\Zimmermann\volumes\postgres\sql. Für die Windows-Verzeichnisse C:\Zimmermann\volumes\postgres\data, C:\Zimmermann\volumes\postgres\tablespace und C:\Zimmermann\volumes\postgres\tablespace\film muss außerdem Vollzugriff gewährt werden, was über das Kontextmenü mit Eigenschaften und den Karteireiter Sicherheit für die Windows-Gruppe Benutzer eingerichtet werden kann. Nun kann man das Auskommentieren des eingeschränkten Linux-Users in docker-compose.yaml wieder rückgängig machen, damit der DB-Server fortan nicht als Superuser "root" läuft. Übrigens ist das Emoji für das Ausrufezeichen von https://emojipedia.org.

    cd .extras\postgres
    docker compose up

    # Herunterfahren in einer 2. Shell:
    cd .extras\postgres
    docker compose down

Der Name des Docker-Containers lautet postgres und ebenso lautet der virtuelle Rechnername postgres. Der virtuelle Rechnername postgres wird später auch als Service-Name für PostgreSQL in Kubernetes verwendet.

❗ Nach dem 1. Start des PostgreSQL-Servers muss man einmalig den Datenbank-User film und dessen Datenbank film anlegen, d.h. der neue Datenbank-User film wird zum Owner der Datenbank film. Dazu muss man sich mit dem Docker-Container mit Namen postgres verbinden und im Docker-Container das bash-Skript ausführen:

    docker compose exec postgres sh
       psql --dbname=postgres --username=postgres --file=/sql/create-db-kunde.sql

Außerdem kann pgadmin zur Administration verwendet werden. pgadmin läuft ebenfalls als Docker-Container und ist über ein virtuelles Netzwerk mit dem Docker-Container des DB-Servers verbunden. Deshalb muss beim Verbinden mit dem DB-Server auch der virtuelle Rechnername postgres verwendet werden. Man ruft also pgadmin mit Chrome und der URL http://localhost:8888 auf. Die Emailadresse [email protected] und das Passwort p sind voreingestellt. Da pgadmin mit Chromium implementiert ist, empfiehlt es sich, Chrome als Webbrowser zu verwenden.

Beim 1. Einloggen konfiguriert man einen Server-Eintrag mit z.B. dem Namen postgres-container und verwendet folgende Werte:

  • Host: postgres (virtueller Rechnername des DB-Servers im Docker-Netzwerk. BEACHTE: localhost ist im virtuellen Netzwerk der Name des pgadmin-Containers selbst !!!)
  • Port: 5432 (Defaultwert)
  • Username: postgres (Superuser beim DB-Server)
  • Password: p

Es empfiehlt sich, das Passwort abzuspeichern, damit man es künftig nicht jedes Mal beim Einloggen eingeben muss.

helmfile für PostgreSQL und pgadmin

Wenn der eigene Server in Kubernetes gestartet werden soll (s.u.), muss PostgreSQL zuvor in Kubernetes gestartet werden, was mit helmfile und manuellem Port-Forwarding für pgadmin gemacht werden kann:

    cd .extras\kubernetes\postgres
    helmfile apply
    .\port-forward.ps1

    # Deinstallieren
    helmfile destroy
    .\delete-pvc.ps1

Das Administrationswerkzeug pgadmin wurde innerhalb von Kubernetes gestartet und kann wegen Port-Forwarding mit http://localhost:8888 aufgerufen werden.

Beim Deinstallieren muss man manuell die 4 PersistentVolumeClaim mit den Namen postgres-data-volume-postgres-0, postgres-conf-volume-postgres-0, pgadmin-pgadmin-volume-pgadmin-0 und pgadmin-pgadmin4-volume-pgadmin-0 löschen, die durch die StatefulSet postgres und pgadmin erstellt wurden. Dazu gibt es das PowerShell-Skript delete-pvc.ps1.

MySQL

Docker Compose für MySQL und phpMyAdmin

Wenn man den eigenen Microservice direkt mit Windows - nicht mit Kubernetes - laufen lässt, kann man MySQL und das Administrationswerkzeug phpMyAdmin einfach mit Docker Compose starten und später auch herunterfahren.

❗ Vor dem 1. Start von MySQL muss man die Skripte create-db-film.sh und create-db-film.sql aus dem Projektverzeichnis .extras\mysql\sql nach C:\Zimmermann\volumes\mysql\sql kopieren.

    cd .extras\mysql
    docker compose up

    # Herunterfahren in einer 2. Shell:
    cd .extras\mysql
    docker compose down

Der Name des Docker-Containers und des virtuellen Rechners lautet mysql. Der virtuelle Rechnername wird später auch als Service-Name für MySQL in Kubernetes verwendet.

❗ Nach dem 1. Start des DB-Servers muss man einmalig den Datenbank-User film und dessen Datenbank film anlegen, d.h. der neue Datenbank-User film wird zum Owner der Datenbank film. Dazu muss man sich mit dem Docker-Container mit Namen mysql verbinden und im Docker-Container das bash-Skript ausführen:

    docker compose exec mysql sh
        mysql --user=root --password=p < /sql/create-db-kunde.sql

Jetzt läuft der DB-Server. Außerdem kann phpMyAdmin zur Administration verwendet werden. phpMyAdmin läuft ebenfalls als Docker-Container und ist über ein virtuelles Netzwerk mit dem Docker-Container des DB-Servers verbunden. Deshalb muss beim Verbinden mit dem DB-Server auch der virtuelle Rechnername mysql verwendet werden. Man ruft also phpMyAdmin mit einem Webbrowser und der URL http://localhost:8889 auf. Zum Einloggen verwendet folgende Werte:

  • Server: mysql (virtueller Rechnername des DB-Servers im Docker-Netzwerk. BEACHTE: localhost ist im virtuellen Netzwerk der Name des phpMyAdmin-Containers selbst !!!)
  • Benutzername: root (Superuser beim DB-Server)
  • Password: p

helmfile für MySQL und phpMyAdmin

Wenn der eigene Server in Kubernetes gestartet werden soll (s.u.), muss MySQL zuvor in Kubernetes gestartet werden, was mit helmfile gemacht werden kann.

    cd .extras\kubernetes\mysql
    helmfile apply
    .\port-forward.ps1

    # Deinstallieren
    helmfile destroy
    .\delete-pvc.ps1

Das Administrationswerkzeug phpMyAdmin wurde innerhalb von Kubernetes gestartet und kann wegen Port-Forwarding mit http://localhost:8889 aufgerufen werden.

Beim Deinstallieren muss man manuell das PersistentVolumeClaim mit den Namen mysql-db-volume-mysql-0 löschen, das durch das StatefulSet mysql erstellt wurde. Dazu gibt es das PowerShell-Skript delete-pvc.ps1.

Administration des Kubernetes-Clusters

Zur Administration des Kubernetes-Clusters ist für Entwickler*innen m.E. Lens von Mirantis oder Octant von VMware Tanzu oder Kui von IBM gut geeignet.

Node Best Practices

Sehr empfehlenswert ist https://github.com/goldbergyoni/nodebestpractices

Lokaler Appserver (mit Nest)

Entwicklung in einer Powershell

Durch npm run start:dev wird der Appserver im Watch-Modus für die Entwicklung gestartet, d.h. bei Code-Änderungen wird der Server automatisch neu gestartet.

Beim Starten des Appservers wird außerdem mit TypeORM auf die Datenbank zugegriffen. Der Benutzername und das Passwort sind in der Datei src\config\db.ts auf admin und p voreingestellt. Bei Kubernetes muss Port-Forwarding (s.o.) aktiviert sein. Dazu muss die Umgebungsvariable DB_HOST in .env auskommentiert sein oder auf den Defaultwert localhost gesetzt sein. Durch die Umgebungsvariable DB_POPULATE wird festgelegt, ob die (Test-) DB film neu geladen wird.

OpenAPI

Duch Decorators @Api...() kann man OpenAPI (früher: Swagger) in den Controller-Klassen und -Methoden konfigurieren und dann in einem Webbrowser mit https://localhost:3000/swagger aufrufen. Die Swagger JSON Datei kann man mit https://localhost:3000/swagger-json aufrufen.

Apollo Sandbox

Ab Apollo 3, das auch intern in Nest verwendet wird, gibt es Apollo Sandbox, das man z.B. mit Chrome nutzen kann. Dabei empfiehlt es sich die Chrome-Erweiterung Apollo Client DevTools von https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm zu installieren. Apollo Sandbox kann man dann mit der URL https://studio.apollographql.com/sandbox/explorer aufrufen.

Um effizient mit Apollo Sandbox zu arbeiten, empfiehlt es sich, dass man sich dort registriert, damit man z.B. Autovervollständigen nutzen kann. Für das Programmierbeispiel kann man beim Registrieren z.B. folgende Daten eingegeben:

Abschließend klickt man dann den Button Create Graph an.

Beispielhafte Queries und Mutations für GraphQL gibt es in den Dateien .extras\restclient\graphql\film.query.http und .extras\restclient\graphql\film.mutation.http.

In der Sandbox kann man z.B. folgende Query absetzen:

... { film(id: "000000000000000000000001") { hauptdarsteller art name version } } ...

Oder unter Verwendung von einer Variablen (hier: filmId):

... query ($filmId: ID!) { film(id: $filmId) { hauptdarsteller art name version } } ...

Dazu muss man im unteren Abschnitt Variables folgendes eintragen:

... { "filmId": "000000000000000000000001" } ...

Außerdem bietet Nest für eine GraphQL-Schnittstelle in einem Webbrowser die URL https://localhost:3000/graphql an, mit der man auf Playground zugreifen kann, der allerdings ab Apollo 3 deprecated ist.

REST Client für eine REST- und eine GraphQL-Schnittstelle

Im Unterverzeichnis .extras\restclient befinden sich in den Unterverzeichnissen rest und graphql mehrere Dateien mit der Extension .rest oder .http. In diesen Dateien sind Interaktionsmöglichkeiten für die REST- und die GraphQL-Schnittstelle.

Wenn man eine dieser Dateien in VS Code öffnet, dann sieht man bei jedem Beispiel bzw. Abschnitt, der mit ### beginnt, eine künstliche Zeile mit Send Request (keine Zeilennummer!). Auf Send Request kann man klicken und der Request wird ausgeführt, wozu natürlich der Server erfolgreich gestartet sein sollte.

Für den REST-Client benötigt man unterschiedliche Umgebungen (Environment) je nachdem, ob der Server lokal oder in einem (lokalen) Kubernetes-Cluster läuft. Verschiedene Umgebungen können prinzipiell die gleichen Eigenschaften, aber mit verschiedenen Werten haben. Beispielsweise lautet die URL für die REST-Schnittstelle beim lokalen Server https://localhost:3000/... aber im Kubernetes-Cluster http://localhost:3000/.... Dazu kann man im Unterverzeichnis .vscode die Datei settings.json bearbeiten.

Wenn man von nun an eine .rest-Datei öffnet, dann sieht man rechts unten in der Statusleiste die aktuelle Umgebung. Sobald man rechts unten auf den Namen der aktuellen Umgebung (oder No Environment) klickt, erscheinen die möglichen Umgebungen in der Auswahl am oberen Fensterrand.

Wenn für die Interaktion mit dem Server Zugriffsberechtigungen erforderlich sind, muss man sich zunächst einloggen und erhält dabei einen (Access-) Token, und zwar einen JWT (= JSON Web Token), so dass "stateless sessions" möglich sind. Nach dem Einloggen kann man den JWT wiederholt verwenden, ohne jedes Mal den Benutzernamen und vor allem das Passwort mitschicken zu müssen - bis zum Ablaufen des Tokens. In der Payload ("Nutzdaten") eines Tokens (siehe https://jwt.io) sind Informationen zum jeweiligen User, so dass dessen Rollen ermittelt werden können, um damit auf der Serverseite die Zugriffsberechtigungen anhand der Rollen zu ermitteln (RBAC = "Role-Based Access Controll").

stateDiagram
  state Gast
  state "JWT = JSON Web Token" as jwt
  state "REST-Schnittstelle" as rest
  state "GraphQL-Schnittstelle" as graphql
  state "RBAC = Role-Based Access Control" as rbac


  [*] --> Gast
  Gast --> jwt : Login, z.B. application/x-www-form-urlencoded
  jwt --> rest : HTTP-Header "Authorization"
  jwt --> graphql : HTTP-Header "Authorization"

  rest --> rbac : Authorisierung
  graphql --> rbac : Authorisierung
Loading

Für die Query-Sprache von GraphQL bietet der REST Client allerdings KEIN Autovervollständigen an, wie man es von Apollo Sandbox und Playground (s.o.) gewohnt ist.

Postman

Als Alternative zu REST Client als Plugin für VS Code kann man auch die Desktop-Applikation Postman nutzen: https://www.postman.com.

Tests aufrufen

Folgende Voraussetzungen müssen oder sollten erfüllt sein:

  • Der DB-Server muss gestartet sein.
  • Port-Forwarding muss für den DB-Server aktiviert sein, falls dieser in Kubernetes läuft.
  • Der Appserver muss nicht gestartet sein.

Nun kann man die Tests folgendermaßen in einer Powershell aufrufen. Dabei wird die Umgebungsvariable LOG_DEFAULT auf true gesetzt, um nicht zu detailliert zu protokollieren bzw. damit die Log-Ausgabe übersichtlich bleibt.

    npm t

Bei der Fehlersuche ist es ratsam, nur eine einzelnen Testdatei aufzurufen, z.B.:

    npm exec jest --detectOpenHandles --errorOnDeprecated `
      --forceExit --runTestsByPath '__tests__\film\film-GET.controller.test.ts'

Deployment in Kubernetes

DB-Server als Voraussetzung

Voraussetzung für das Deployment des Microservice ist, dass der DB-Server erfolgreich gestartet ist (s.o.).

Docker-Image durch Buildpacks

Mittels (Cloud Native) Buildpacks und der Konfigurationsdatei project.toml kann man ein Docker Image erstellen, ohne dass ein Dockerfile erforderlich ist. Das resultierende Image basiert auf Ubuntu und erfordert, dass die TypeScript-Dateien in JavaScript übersetzt sind. Durch das npm-Skript pack wird das Docker-Image docker.io/juergenzimmermann/film:2023.1.0 mit dem implizit übersetzten JavaScript-Code gebaut:

    # In der 2. PowerShell
    npm run pack

Wie das Docker-Image gebaut wurde, kann man anschließend mit folgendem Kommando inspizieren:

    pack inspect juergenzimmermann/film:2023.1.0

Deployment mit Helm

Im Verzeichnis .extras\film ist ein Helm-Chart für die Entwicklung des Appservers. Wenn das Docker-Image erstellt ist (s.o.), kann die Installation in Kubernetes mit helmfile apply mittels im Wurzelverzeichnis durchgeführt werden. Dabei wird helmfile.yaml verwendet.

Mit Lens kann man anschließend die Installation inspizieren. Dabei wird die Logdatei im internen Verzeichnis /var/log/node angelegt, welches durch Mounting dem Windows-Verzeichnis C:\Zimmermann\volumes\film entspricht und mit Schreibberechtigung existieren muss.

Außerdem kann man in .extras\film eine Datei README.md generieren, die die Default-Konfigurationswerte für die Helm-basierte Installation enthält. Dazu ruft man in .extras\film das Kommando helm-docs auf.

Die Installation kann entsprechend mit helmfile destroy wieder aus Kubernetes entfernt werden.

Statische Codeanalyse

ESLint

ESLint wird durch folgendes npm-Skript ausgeführt:

    npm run eslint

SonarQube

Für eine statische Codeanalyse durch SonarQube muss zunächst der SonarQube-Server mit Docker Compose als Docker-Container gestartet werden:

    cd .extras\sonarqube
    docker compose up

Wenn der Server zum ersten Mal gestartet wird, ruft man in einem Webbrowser die URL http://localhost:9000 auf. In der Startseite muss man sich einloggen und verwendet dazu als Loginname admin und ebenso als Password admin. Danach wird man weitergeleitet, um das initiale Passwort zu ändern. Das neue Passwort trägt man dann in das Skript sonar-scanner.ps1 im Wurzelverzeichnis ein. Zur Konfiguration für künftige Aufrufe des SonarQube-Scanners trägt man jetzt noch in der Konfigurationsdatei sonar-project.properties den Projektnamen beim der Property sonar.projectKey ein.

Nachdem der Server gestartet ist, wird der SonarQube-Scanner in einer zweiten PowerShell mit dem Skript sonar-scanner.ps1 gestartet. Das Resultat kann dann in der Webseite des zuvor gestarteten Servers über die URL http://localhost:9000 inspiziert werden.

Abschließend wird der oben gestartete Server heruntergefahren.

    cd .extras\sonarqube
    docker compose down

type-coverage

Mit type-coverage kann man ermitteln, wo im TypeScript-Code any verwendet wurde:

    npm run type-coverage

Sicherheitsanalyse durch snyk

Zunächst muss man sich bei https://app.snyk.io/account registrieren und dort auch einen Token besorgen. Danach kann man sich folgendermaßen authentifizieren und das Projekt auf Sicherheitslücken überprüfen

    synk auth <MEIN_TOKEN>
    snyk test

AsciiDoctor und PlantUML

Mit AsciiDoctor und PlantUML ist die Dokumentation geschrieben.

Preview von PlantUML-Dateien

Durch das Tastaturkürzel <Alt>d. Dazu ist eine Internet-Verbindung notwendig. Beispiele für PlantUML und AsciiDoctor sind im Unterverzeichnis .extras\doc.

Einstellungen für Preview von AsciiDoctor-Dateien

Zunächst müssen einmalig die Einstellungen (Settings) von VS Code geändert werden. Dazu geht man über zum Menüpunkt Datei > Einstellungen > Einstellungen und gibt im Suchfeld asciidoc.use_kroki ein. Nun setzt man den Haken bei Enable kroki integration to generate diagrams.

Wenn man zum ersten Mal eine .adoc-Datei im Editor öffnet, muss man noch die Verbindung zum PlantUML-Server zulassen, damit die eingebundenen .puml-Dateien in .svg-Dateien konvertiert werden. Dazu gibt man zunächst das <F1> ein und schickt im Eingabefeld das Kommando AsciiDoc: Change Preview Security Settings durch <Enter> ab. Danach wählt man den Unterpunkt Allow insecure content aus.

Preview von AsciiDoctor-Dateien

Durch das Tastaturkürzel <Strg><Shift>v. Dazu ist eine Internet-Verbindung notwendig.

Dokumentation im Format HTML

Die Dokumentation im Format HTML wird in einer Powershell folgendermaßen im Verzeichnis .extras\doc\html erstellt:

    npm run asciidoc

Continuous Integration mit Jenkins

Jenkins wird nicht in Kubernetes, sondern direkt mit Docker Compose genutzt. Dadurch muss Jenkins nicht immer laufen und kann bei Bedarf gestartet und wieder heruntergefahren werden. Dazu muss zunächst das Jenkins-Image um eine Docker-Installation ergänzt werden, wozu es im Unterverzeichnis .extras\jenkins das Dockerfile gibt, um ein solches Image zu erstellen:

    cd .extras\jenkins
    Get-Content Dockerfile | docker run --rm --interactive hadolint/hadolint:2.10.0-beta-debian
    docker buildx build --tag juergenzimmermann/jenkins:2023.1.0 .

Das neu gebaute Image juergenzimmermann/jenkins:2023.1.0 wird in docker-compose.yaml verwendet:

    cd .extras\jenkins
    docker compose up

    # In einer 2. PowerShell: Herunterfahren
    docker compose down

Aufruf mit Webbrowser

Mit der URL https://localhost:7070 kann man von einem Webbrowser auf das Jenkins-Image zugreifen. Der Benutzername ist admin und das Passwort Inf und WI..

Bash zur evtl. Fehlersuche im laufenden Jenkins-Container

    cd .extras\jenkins
    docker compose exec jenkins bash

Monitoring durch clinic

Für Monitoring kann man z.B. clinic nutzen, indem man zunächst dem TypeScript-Compiler durch npm run tsc aufruft und danach npm run clinic.

Allerdings gibt es noch das offene Ticket https://github.com/clinicjs/node-clinic-doctor/issues/304

Visual Studio Code

Visual Studio Code kann man kostenfrei herunterladen.

Tipps:

Empfohlene Code-Konventionen

In Anlehnung an die Guidelines von TypeScript

  • "Feature Filenames", z.B. film.service.ts
  • Klassennamen mit PascalCase
  • Union-Types (mit Strings) statt Enums
  • Attribute und Funktionen mit camelCase
  • # für private Properties
  • private Properties nicht mit vorangestelltem _
  • Interfaces nicht mit vorangestelltem I
  • Higher-Order Functions: [...].forEach(), [...].filter() und [...].map()
  • Arrow-Functions statt function()
  • undefined verwenden und nicht null
  • Geschweifte Klammern bei if-Anweisungen
  • Maximale Dateigröße: 400 Zeilen
  • Maximale Funktionsgröße: 75 Zeilen

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 3

  •  
  •  
  •  

Languages