Schließlich öffnet das Skript automatisch den Browser und meldet Sie bei StackRox an. Möglicherweise wird eine Zertifikatwarnung angezeigt, da das Zertifikat selbstsigniert ist. Weitere Informationen zu den Warnungen finden Sie im Abschnitt Zugriff auf die StackRox-Benutzeroberfläche (UI). Nach der Authentifizierung können Sie über https://localhost:8000/main/dashboard auf das Dashboard zugreifen.

Zuerst werden die StackRox Central Services zu Ihrem Kubernetes-Cluster hinzugefügt. Dies umfasst die UI und den Scanner. Fügen Sie zunächst das Repository stackrox/helm-charts/opensource zu Helm hinzu.```sh helm repo add stackrox https://raw.githubusercontent.com/stackrox/helm-charts/main/opensource/

Um alle verfügbaren Helm-Charts im Repository anzuzeigen, führen Sie aus (Sie können die Option `--devel` hinzufügen, um auch Nicht-Release-Builds anzuzeigen).```sh
helm search repo stackrox

Um stackrox-central-services zu installieren, benötigen Sie ein sicheres Passwort. Dieses Passwort wird später für die UI-Anmeldung und beim Erstellen eines init bundles benötigt.```sh ROX_ADMIN_PASSWORD="$(openssl rand -base64 20 | tr -d '/=+')"

From here, you can install stackrox-central-services to get Central and Scanner components deployed on your cluster.

> **Hinweis:**
> Sie benötigen nur eine bereitgestellte Instanz von stackrox-central-services, selbst wenn Sie mehrere Cluster sichern möchten.

#### Standard-Central-Installation

Wenn Sie in einem einigermaßen großen Cluster installieren, verwenden Sie den Standard-Installationsbefehl:```sh
helm upgrade --install -n stackrox --create-namespace stackrox-central-services \
  stackrox/stackrox-central-services \
  --set central.adminPassword.value="${ROX_ADMIN_PASSWORD}" \
  --set central.persistence.none="true"

Zentrale Installation in Clustern mit begrenzten Ressourcen

Wenn Sie in einem Single-Node-Cluster installieren oder die Standardinstallation dazu führt, dass Pods aufgrund von Ressourcenmangel im Status "Pending" hängen bleiben, verwenden Sie stattdessen den folgenden Befehl, um die Ressourcenanforderungen von stackrox-central-services zu reduzieren. Beachten Sie, dass diese reduzierten Ressourceneinstellungen nicht für eine Produktionsumgebung geeignet sind.```sh helm upgrade --install -n stackrox --create-namespace stackrox-central-services
stackrox/stackrox-central-services
--set central.adminPassword.value="${ROX_ADMIN_PASSWORD}"
--set central.persistence.none="true"
--set central.resources.requests.memory=1Gi
--set central.resources.requests.cpu=1
--set central.resources.limits.memory=4Gi
--set central.resources.limits.cpu=1
--set central.db.resources.requests.memory=1Gi
--set central.db.resources.requests.cpu=500m
--set central.db.resources.limits.memory=4Gi
--set central.db.resources.limits.cpu=1
--set scanner.autoscaling.disable=true
--set scanner.replicas=1
--set scanner.resources.requests.memory=500Mi
--set scanner.resources.requests.cpu=500m
--set scanner.resources.limits.memory=2500Mi
--set scanner.resources.limits.cpu=2000m

</details>

<details><summary>Install StackRox Secured Cluster Services</summary>

Als nächstes muss die Komponente des gesicherten Clusters bereitgestellt werden, um Informationen von den Kubernetes-Knoten zu sammeln.

Setzen Sie einen aussagekräftigen Clusternamen für Ihren gesicherten Cluster in der Shell-Variable `CLUSTER_NAME`. Der Cluster wird unter diesem Namen in der Clusterliste der StackRox UI identifiziert.```sh
CLUSTER_NAME="my-secured-cluster"

Setzen Sie den Endpunkt fest, mit dem die gesicherten Cluster-Dienste kommunizieren sollen. Wenn Sie stackrox-secured-cluster-services auf demselben Cluster wie stackrox-central-services bereitstellen, belassen Sie ihn wie gezeigt, andernfalls ändern Sie den Wert auf den Endpunkt, über den Central erreichbar ist.```sh CENTRAL_ENDPOINT="central.stackrox.svc:443"

Generieren Sie ein Init-Bundle, das Initialisierungsgeheimnisse enthält. Das Init-Bundle wird in `stackrox-init-bundle.yaml` gespeichert, und Sie werden es verwenden, um gesicherte Cluster wie unten gezeigt bereitzustellen.```sh
echo "$ROX_ADMIN_PASSWORD" | \
kubectl -n stackrox exec -i deploy/central -- bash -c 'ROX_ADMIN_PASSWORD=$(cat) roxctl --insecure-skip-tls-verify \
  central init-bundles generate stackrox-init-bundle --output -' > stackrox-init-bundle.yaml

Installieren Sie dann stackrox-secured-cluster-services (mit dem soeben generierten Init-Bundle).

Führen Sie die Installation mit einem der folgenden Befehle aus, abhängig von der Größe Ihres Clusters.

Default Secured Cluster Services Installation

Wenn Sie in einem Cluster mit angemessener Größe installieren, verwenden Sie den standardmäßigen Installationsbefehl:```sh helm upgrade --install -n stackrox --create-namespace stackrox-secured-cluster-services
stackrox/stackrox-secured-cluster-services
-f stackrox-init-bundle.yaml
--set clusterName="$CLUSTER_NAME"
--set centralEndpoint="$CENTRAL_ENDPOINT"

#### Installation von Secured Cluster Services in Clustern mit begrenzten Ressourcen

Wenn Sie in einem Single-Node-Cluster installieren oder die Standardinstallation aufgrund von Ressourcenmangel zu in "pending" hängenden Pods führt, verwenden Sie stattdessen den folgenden Befehl, um die Ressourcenanforderungen von stackrox-secured-cluster-services zu reduzieren. Beachten Sie, dass diese reduzierten Ressourceneinstellungen für eine Produktionsumgebung nicht geeignet sind.```sh
helm upgrade --install -n stackrox --create-namespace stackrox-secured-cluster-services \
  stackrox/stackrox-secured-cluster-services \
  -f stackrox-init-bundle.yaml \
  --set clusterName="$CLUSTER_NAME" \
  --set centralEndpoint="$CENTRAL_ENDPOINT" \
  --set sensor.resources.requests.memory=500Mi \
  --set sensor.resources.requests.cpu=500m \
  --set sensor.resources.limits.memory=500Mi \
  --set sensor.resources.limits.cpu=500m

Um Ihre Helm-Installation weiter anzupassen, konsultieren Sie diese Dokumente:

• https://docs.openshift.com/acs/installing/installing_other/install-central-other.html#install-using-helm-customizations-other
• https://docs.openshift.com/acs/installing/installing_other/install-secured-cluster-other.html#configure-secured-cluster-services-helm-chart-customizations-other

Befolgen Sie die folgende Anleitung, um schnell eine bestimmte Version von StackRox in Ihrem Kubernetes-Cluster im stackrox-Namespace bereitzustellen. Wenn Sie eine bestimmte Version installieren möchten, definieren/setzen Sie diese in MAIN_IMAGE_TAG, ansonsten wird der neueste nächtliche Build installiert.

Führen Sie Folgendes in Ihrem Arbeitsverzeichnis Ihrer Wahl aus:``` git clone [email protected]:stackrox/stackrox.git cd stackrox MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Nach einigen Minuten sollten alle Ressourcen bereitgestellt sein.

**Die Anmeldeinformationen für den Benutzer 'admin' finden Sie in der Datei `./deploy/k8s/central-deploy/password`.**

> **Hinweis:**
> Die Passwortdatei wird im Klartext auf Ihrem lokalen Dateisystem gespeichert, aber das von StackRox daraus erstellte Kubernetes-Secret ist verschlüsselt. Sie können das Passwort zur Laufzeit nicht ändern. Wenn Sie das Passwort verlieren, müssen Sie Central erneut bereitstellen.

</details>

#### OpenShift

<details><summary>Zum Erweitern klicken</summary>

Bevor Sie auf OpenShift bereitstellen, stellen Sie sicher, dass Sie die [oc - OpenShift Befehlszeile](https://github.com/openshift/oc) installiert haben.

Folgen Sie der Anleitung unten, um schnell eine bestimmte Version von StackRox in Ihrem OpenShift-Cluster im Namensraum `stackrox` bereitzustellen. Stellen Sie sicher, dass Sie den neuesten Tag zur Variable `MAIN_IMAGE_TAG` hinzufügen.

Führen Sie Folgendes in Ihrem Arbeitsverzeichnis Ihrer Wahl aus:```
git clone [email protected]:stackrox/stackrox.git
cd stackrox
MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Nach einigen Minuten sollten alle Ressourcen bereitgestellt sein. Der Vorgang wird mit dieser Nachricht abgeschlossen.

Die Anmeldedaten für den Benutzer 'admin' finden Sie in der Datei ./deploy/openshift/central-deploy/password.

Hinweis: Während die Passwortdatei im Klartext auf Ihrem lokalen Dateisystem gespeichert ist, ist das von StackRox verwendete Kubernetes-Secret verschlüsselt, und Sie können das Secret zur Laufzeit nicht ändern. Wenn Sie das Passwort verlieren, müssen Sie Central erneut bereitstellen.

Führen Sie den folgenden Befehl in Ihrem Arbeitsverzeichnis Ihrer Wahl aus:``` git clone [email protected]:stackrox/stackrox.git cd stackrox MAIN_IMAGE_TAG=latest ./deploy/deploy-local.sh

Nach einigen Minuten sollten alle Ressourcen bereitgestellt sein.

**Anmeldeinformationen für den Benutzer 'admin' finden Sie in der Datei `./deploy/k8s/deploy-local/password`.**

</details>

## Zugriff auf die StackRox-Benutzeroberfläche (UI)

<details><summary>Zum Erweitern klicken</summary>

Nach Abschluss der Bereitstellung (Operator-, Helm- oder Skriptinstallation) sollte ein Port-Forward existieren, sodass Sie sich mit https://localhost:8000/ verbinden können. Führen Sie Folgendes aus```sh
kubectl port-forward -n 'stackrox' svc/central "8000:443"

Gehen Sie dann in Ihrem Webbrowser zu https://localhost:8000/.

Benutzername = Der Standardbenutzer ist admin

Passwort (Helm) = Das Passwort befindet sich nach einer manuellen Installation in $ROX_ADMIN_PASSWORD oder wird am Ende des Schnellinstallationsskripts ausgegeben.

Passwort (Skript) = Das Passwort befindet sich bei der Skriptinstallation im Ordner /deploy/<orchestrator>/central-deploy/password.txt.

• Make
• Go
• Verschiedene Go-Linter, die mit make reinstall-dev-tools installiert werden können.
• UI-Build-Werkzeuge wie in ui/README.md beschrieben.
• Docker
  • Hinweis: Docker Desktop erfordert nun ein kostenpflichtiges Abonnement für größere Unternehmen.
  • Einige StackRox-Entwickler empfehlen Colima
• Xcode Befehlszeilenwerkzeuge (nur macOS)
• Bats wird verwendet, um bestimmte Shell-Tests auszuführen. Sie können es mit brew install bats oder npm install -g bats beziehen.
• oc OpenShift CLI-Werkzeug
• shellcheck für Linting von Shell-Skripten.

Xcode - nur macOS

Normalerweise wären diese bereits durch brew installiert. Wenn jedoch beim Bauen der golang x/tools ein Fehler auftritt, versuchen Sie zuerst sicherzustellen, dass die EULA akzeptiert ist durch:

1. Xcode starten
2. ein neues leeres App-Projekt erstellen
3. die App des leeren Projekts im Emulator starten
4. sowohl den Emulator als auch Xcode schließen, dann
5. die folgenden Befehle ausführen: ```bash xcode-select --install sudo xcode-select --switch /Library/Developer/CommandLineTools # Enable command line tools sudo xcode-select -s /Applications/Xcode.app/Contents/Developer

Weitere Informationen finden Sie unter <https://github.com/nodejs/node-gyp/issues/569>

</details>

#### StackRox klonen
<details><summary>Klicken zum Erweitern</summary>```bash
# Create a GOPATH: this is the location of your Go "workspace".
# (Note that it is not – and must not – be the same as the path Go is installed to.)
# The default is to have it in ~/go/, or ~/development, but anything you prefer goes.
# Whatever you decide, create the directory, set GOPATH, and update PATH:
export GOPATH=$HOME/go # Change this if you choose to use a different workspace.
export PATH=$PATH:$GOPATH/bin
# You probably want to permanently set these by adding the following commands to your shell
# configuration (e.g. ~/.bash_profile)

cd $GOPATH
mkdir -p bin pkg
mkdir -p src/github.com/stackrox
cd src/github.com/stackrox
git clone [email protected]:stackrox/stackrox.git

Um Ihre Erfahrung zu verbessern, installieren Sie vorab die Arbeitsablauf-Skripte.```bash $ cd $GOPATH/src/github.com/stackrox/stackrox $ make install-dev-tools $ make image

Jetzt müssen Sie *selbst* einen Kubernetes-Cluster starten, bevor Sie fortfahren.
Die Entwicklung kann entweder in GCP oder lokal mit
[Docker Desktop](https://docs.docker.com/desktop/kubernetes/), [Colima](https://github.com/abiosoft/colima#kubernetes), [minikube](https://minikube.sigs.k8s.io/docs/start/) erfolgen.

> **Hinweis:**
> Docker Desktop und Colima sind besser für die macOS-Entwicklung geeignet, da der Cluster auf lokal mit `make image` erstellte Images zugreifen kann, ohne zusätzliche Konfiguration. Außerdem bietet Collector eine bessere Unterstützung für diese als für minikube, wo Treiber möglicherweise nicht verfügbar sind.```bash
# To keep the StackRox Central's Postgres DB state between database upgrades and restarts, set:
$ export STORAGE=pvc

# To save time on rebuilds by skipping UI builds, set:
$ export SKIP_UI_BUILD=1

# To save time on rebuilds by skipping CLI builds, set:
$ export SKIP_CLI_BUILD=1

# When you deploy locally make sure your kube context points to the desired kubernetes cluster,
# for example Docker Desktop.
# To check the current context you can call a workflow script:
$ roxkubectx

# To deploy locally, call:
$ ./deploy/deploy-local.sh

# Now you can access StackRox dashboard at https://localhost:8000
# or simply call another workflow script:
$ logmein

Siehe Installation via Scripts für weitere Informationen. Um mehr über die Umgebungsvariablen zu erfahren, konsultieren Sie deploy/README.md.

Compile all binaries

$ make main-build-dockerized

Displays the docker image tag which would be generated

$ make tag

Note: there are integration tests in some components, and we currently

run those manually. They will be re-enabled at some point.

$ make test

Apply and check style standards in Go and JavaScript

$ make style

enable pre-commit hooks for style checks

$ make init-githooks

Compile and restart only central

$ make fast-central

Compile only sensor

$ make fast-sensor

Only compile protobuf

$ make proto-generated-srcs

</details>

#### Produktivität

<details><summary>Klicken zum Erweitern</summary>

Das [workflow repository](https://github.com/stackrox/workflow) enthält einige Hilfsskripte, die unseren Entwicklungsablauf unterstützen. Entdecke weitere Befehle mit `roxhelp --list-all`.```bash
# Change directory to rox root
$ cdrox

# Handy curl shortcut for your StackRox central instance
# Uses https://localhost:8000 by default or ROX_BASE_URL env variable
# Also uses the admin credentials from your last deployment via deploy.sh
$ roxcurl /v1/metadata

# Run quickstyle checks, faster than stackrox's "make style"
$ quickstyle

# The workflow repository includes some tools for supporting
# working with multiple inter-dependent branches.
# Examples:
$ smart-branch <branch-name>    # create new branch
    ... work on branch...
$ smart-rebase                  # rebase from parent branch
    ... continue working on branch...
$ smart-diff                    # check diff relative to parent branch
    ... git push, etc.

Wenn Sie GoLand für die Entwicklung verwenden, kann Folgendes die Erfahrung verbessern.

Stellen Sie sicher, dass das Protocol Buffers-Plugin installiert ist. Das Plugin ist standardmäßig in GoLand installiert. Falls nicht, verwenden Sie Help | Find Action..., geben Sie Plugins ein und drücken Sie die Eingabetaste, wechseln Sie dann zu Marketplace, geben Sie den Namen ein und installieren Sie das Plugin.

Dieses Plugin weiß standardmäßig nicht, wo es nach .proto-Imports suchen soll. Daher müssen Sie explizit Pfade für dieses Plugin konfigurieren. Siehe https://github.com/jvolkman/intellij-protobuf-editor#path-settings.

• Gehen Sie zu GoLand | Preferences | Languages & Frameworks | Protocol Buffers.
• Deaktivieren Sie Configure automatically.
• Klicken Sie auf die Schaltfläche +, navigieren Sie und wählen Sie das Verzeichnis ./proto im Stammverzeichnis des Repos aus.
• Optional können Sie auch $HOME/go/pkg/mod/github.com/gogo/[email protected] und $HOME/go/pkg/mod/github.com/gogo/[email protected]/ hinzufügen.
• Zur Überprüfung: Verwenden Sie das Menü Navigate | File..., geben Sie einen beliebigen .proto-Dateinamen ein, z.B. alert_service.proto, und prüfen Sie, dass alle Import-Strings grün und nicht rot angezeigt werden.

Go-Tests, die mit //go:build sql_integration annotiert sind, benötigen einen PostgreSQL-Server, der auf Port 5432 lauscht. Aufgrund der Art und Weise, wie die Authentifizierung im Code eingerichtet ist, ist es am einfachsten, Postgres in einem Container wie folgt zu starten:```bash $ docker run --rm --env POSTGRES_USER="$USER" --env POSTGRES_HOST_AUTH_METHOD=trust --publish 5432:5432 docker.io/library/postgres:15

Während dies im Hintergrund läuft, können `sql_integration`-Tests aus der IDE oder der Befehlszeile gestartet werden.

</details>

#### Debuggen

<details><summary>Klicken zum Erweitern</summary>

**Einrichtung des Kubernetes-Debuggers**

Mit GoLand können Sie beim Ausführen von Unit-Tests in der IDE ganz natürlich Haltepunkte und den Debugger verwenden.

Wenn Sie lokale oder sogar entfernte Bereitstellungen debuggen möchten, befolgen Sie das folgende Verfahren.

1. Erstellen Sie lokal einen Debug-Build, indem Sie `DEBUG_BUILD=yes` exportieren:   ```bash
   $ DEBUG_BUILD=yes make image

Alternativ wird ein Debug-Build auch erstellt, wenn der Branchname die Teilzeichenkette -debug enthält. Dies funktioniert lokal mit make image und in CI. 2. Stellen Sie das Image mithilfe der Anweisungen in dieser README-Datei bereit. Funktioniert sowohl mit deploy-local.sh als auch mit deploy.sh. 3. Starten Sie den Debugger (und die Portweiterleitung) im Ziel-Pod mit dem Befehl roxdebug aus dem Repository workflow. ```bash

For Central

$ roxdebug

For Sensor

$ roxdebug deploy/sensor

See usage help

$ roxdebug --help

4. Konfigurieren Sie GoLand für das Remote-Debugging (sollte nur einmal durchgeführt werden):
 1. Öffnen Sie `Run | Edit Configurations …`, klicken Sie auf das `+`-Symbol, um eine neue Konfiguration hinzuzufügen, und wählen Sie die Vorlage `Go Remote`.
 2. Wählen Sie `Host:` `localhost` und `Port:` `40000`. Geben Sie dieser Konfiguration einen Namen.
 3. Wählen Sie `On disconnect:` `Leave it running` (dies verhindert, dass GoLand nach dem erneuten Verbinden die Haltepunkte vergisst).
5. Verbinden Sie GoLand mit dem Debugging-Port: Wählen Sie `Run | Debug…` und die von Ihnen erstellte Konfiguration.
Wenn alles richtig gemacht wurde, sollten Sie die Meldung `Connected` im Fenster `Debug | Debugger | Variables` im unteren Teil
des Bildschirms sehen.
6. Setzen Sie einige Code-Haltepunkte, lösen Sie entsprechende Aktionen aus und viel Spaß beim Debuggen!

Siehe [Debuggen von Go-Code, der in Kubernetes ausgeführt wird](https://github.com/stackrox/dev-docs/blob/main/docs/knowledge-base/%5BBE%5D%20Debugging-go-code-running-in-Kubernetes.md) für
weitere Informationen.
</details>

## Erstellen portabler Installationsprogramme

<details><summary>Kubernetes</summary>```bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > k8s.zip

Dies wird Sie durch einen Installer führen und eine k8s.zip-Datei generieren.```bash unzip k8s.zip -d k8s

Bitte fügen Sie den zu übersetzenden Markdown-Inhalt ein.```bash
bash k8s/central.sh

Jetzt wurde Central bereitgestellt. Verwenden Sie die UI, um Sensor bereitzustellen.

Hinweis: Wenn Sie einen Host-Mount verwenden, müssen Sie dem Container den Zugriff darauf ermöglichen, indem Sie sudo chcon -Rt svirt_sandbox_file_t <full volume path> verwenden.

Nehmen Sie das Skript image-setup.sh aus diesem Repository und führen Sie es aus, um den Pull/Push in das lokale OpenShift-Registry durchzuführen. Dies ist eine Voraussetzung für jeden neuen Cluster.```bash bash image-setup.sh

``````bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > openshift.zip

Dies führt Sie durch einen Installer und generiert eine openshift.zip-Datei.```bash unzip openshift.zip -d openshift

Kein Inhalt zur Übersetzung angegeben.```bash
bash openshift/central.sh

Die folgenden Informationen wurden zusammengestellt, um bei der Installation und dem Betrieb des Open-Source-Projekts StackRox zu helfen. Diese Empfehlungen wurden für das Produkt Red Hat Advanced Cluster Security for Kubernetes entwickelt und wurden nicht mit dem Upstream-Projekt StackRox getestet.

Empfohlene Kubernetes-Distributionen

Die Kubernetes-Plattformen, auf denen StackRox mit minimalen Problemen bereitgestellt wurde, sind unten aufgeführt.

• Red Hat OpenShift Dedicated (OSD)
• Azure Red Hat OpenShift (ARO)
• Red Hat OpenShift Service on AWS (ROSA)
• Amazon Elastic Kubernetes Service (EKS)
• Google Kubernetes Engine (GKE)
• Microsoft Azure Kubernetes Service (AKS)

Wenn Sie StackRox auf einer anderen Kubernetes-Distribution als den oben genannten bereitstellen, können Probleme auftreten.

Empfohlene Betriebssysteme

StackRox funktioniert bekanntermaßen auf den neuesten Versionen der folgenden Betriebssysteme.

• Ubuntu
• Debian
• Red Hat Enterprise Linux (RHEL)
• CentOS
• Fedora CoreOS
• Flatcar Container Linux
• Google COS
• Amazon Linux
• Garden Linux

Empfohlene Webbrowser

Die folgende Liste zeigt die Browser, die die StackRox-Webbenutzeroberfläche anzeigen können.

• Google Chrome 88.0 (64-bit)
• Microsoft Internet Explorer Edge
  • Version 44 and later (Windows)
  • Version 81 (Official build) (64-bit)
• Safari on MacOS (Mojave) - Version 14.0
• Mozilla Firefox Version 82.0.2 (64-bit)