Infine, lo script aprirà automaticamente il browser e ti farà accedere a StackRox. Potrebbe essere visualizzato un avviso di certificato poiché il certificato è autofirmato. Consulta la sezione Accesso all'interfaccia utente di StackRox (UI) per maggiori informazioni sugli avvisi. Dopo l'autenticazione puoi accedere alla dashboard utilizzando https://localhost:8000/main/dashboard.

Innanzitutto, StackRox Central Services verrà aggiunto al tuo cluster Kubernetes. Questo include l'interfaccia utente (UI) e lo Scanner. Per iniziare, aggiungi il repository stackrox/helm-charts/opensource a Helm.```sh helm repo add stackrox https://raw.githubusercontent.com/stackrox/helm-charts/main/opensource/

Per vedere tutti i chart Helm disponibili nel repository esegui (puoi aggiungere l'opzione `--devel` per mostrare anche le build non rilasciate)```sh
helm search repo stackrox

Per installare stackrox-central-services, avrai bisogno di una password sicura. Questa password sarà necessaria in seguito per l'accesso all'interfaccia utente e durante la creazione di un init bundle.```sh ROX_ADMIN_PASSWORD="$(openssl rand -base64 20 | tr -d '/=+')"

Da qui, puoi installare stackrox-central-services per distribuire i componenti Central e Scanner sul tuo cluster.

> **Nota:**
> È necessaria una sola istanza distribuita di stackrox-central-services, anche se prevedi di proteggere più cluster.

Per eseguire l'installazione, scegli uno dei seguenti comandi in base alla dimensione del tuo cluster.

#### Installazione Central predefinita

Se stai installando in un cluster di dimensioni ragionevoli, usa il comando di installazione predefinito:```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"

Installazione centrale in cluster con risorse limitate

Se stai installando in un cluster a singolo nodo, o se l'installazione predefinita causa pod bloccati in stato pending per mancanza di risorse, utilizza invece il seguente comando per ridurre i requisiti di risorse di stackrox-central-services. Tieni presente che queste impostazioni di risorse ridotte non sono adatte a un ambiente di produzione.```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>Installa i servizi del cluster protetto di StackRox</summary>

Successivamente, il componente del cluster protetto dovrà essere distribuito per raccogliere informazioni dai nodi Kubernetes.

Imposta un nome significativo per il tuo cluster protetto nella variabile shell `CLUSTER_NAME`. Il cluster sarà identificato con questo nome nell'elenco dei cluster dell'interfaccia utente di StackRox.```sh
CLUSTER_NAME="my-secured-cluster"

Imposta l'endpoint a cui i Secured Cluster Services devono comunicare con Central. Se stai distribuendo stackrox-secured-cluster-services sullo stesso cluster di stackrox-central-services, lascialo come mostrato, altrimenti modifica il valore all'endpoint attraverso cui Central è accessibile.```sh CENTRAL_ENDPOINT="central.stackrox.svc:443"

Genera un bundle di inizializzazione contenente i segreti di inizializzazione. Il bundle di inizializzazione verrà salvato in `stackrox-init-bundle.yaml` e lo utilizzerai per effettuare il provisioning di cluster protetti come mostrato di seguito.```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

Then install stackrox-secured-cluster-services (con il bundle init appena generato).

Per eseguire l'installazione, scegli uno dei seguenti comandi in base alla dimensione del tuo cluster.

Installazione predefinita dei Secured Cluster Services

Se stai installando in un cluster di dimensioni ragionevoli, usa il comando di installazione predefinito:```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"

#### Installazione dei servizi di cluster protetti in cluster con risorse limitate

Se stai installando in un cluster a nodo singolo, o l'installazione predefinita causa la sospensione dei pods a causa di risorse insufficienti, usa il seguente comando per ridurre i requisiti di risorse di stackrox-secured-cluster-services. Tieni presente che queste impostazioni di risorse ridotte non sono adatte per un ambiente di produzione.```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

Per personalizzare ulteriormente la tua installazione Helm, consulta questi documenti:

• 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

Segui la guida qui sotto per distribuire rapidamente una versione specifica di StackRox nel tuo cluster Kubernetes nel namespace stackrox. Se desideri installare una versione specifica, assicurati di definirla/impostarla in MAIN_IMAGE_TAG, altrimenti verrà installata l'ultima nightly build.

Esegui quanto segue nella tua directory di lavoro preferita:``` git clone [email protected]:stackrox/stackrox.git cd stackrox MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

After a few minutes, all resources should be deployed.

**Credentials for the 'admin' user can be found in the `./deploy/k8s/central-deploy/password` file.**

> **Nota:**
> Il file della password è memorizzato in chiaro sul tuo filesystem locale, ma il segreto Kubernetes che StackRox crea da esso è crittografato. Non sarà possibile modificare la password in esecuzione. Se perdi la password, dovrai ridistribuire central.

</details>

#### OpenShift

<details><summary>Clicca per espandere</summary>

Prima di distribuire su OpenShift, assicurati di avere installato [oc - OpenShift Command Line](https://github.com/openshift/oc).

Segui la guida qui sotto per distribuire rapidamente una versione specifica di StackRox sul tuo cluster OpenShift nel namespace `stackrox`. Assicurati di aggiungere il tag più recente alla variabile `MAIN_IMAGE_TAG`.

Esegui il seguente comando nella directory di lavoro che preferisci:```
git clone [email protected]:stackrox/stackrox.git
cd stackrox
MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Dopo alcuni minuti, tutte le risorse dovrebbero essere distribuite. Il processo si completerà con questo messaggio.

Le credenziali per l'utente 'admin' si trovano nel file ./deploy/openshift/central-deploy/password.

Nota: Mentre il file della password è memorizzato in chiaro sul tuo filesystem locale, il Secret Kubernetes utilizzato da StackRox è crittografato e non sarà possibile modificare il secret in fase di esecuzione. Se perdi la password, dovrai ridistribuire central.

Esegui quanto segue nella directory di lavoro di tua scelta:``` git clone [email protected]:stackrox/stackrox.git cd stackrox MAIN_IMAGE_TAG=latest ./deploy/deploy-local.sh

Dopo alcuni minuti, tutte le risorse dovrebbero essere distribuite.

**Le credenziali per l'utente 'admin' si trovano nel file `./deploy/k8s/deploy-local/password`.**

</details>

## Accesso all'Interfaccia Utente (UI) di StackRox

<details><summary>Clicca per espandere</summary>

Dopo che la distribuzione è stata completata (operator, Helm o installazione tramite script), dovrebbe esistere un port-forward, così puoi connetterti a https://localhost:8000/. Esegui il seguente```sh
kubectl port-forward -n 'stackrox' svc/central "8000:443"

Then go to https://localhost:8000/ in your web browser.

Username = The default user is admin

Password (Helm) = The password is in $ROX_ADMIN_PASSWORD after a manual installation, or printed at the end of the quick installation script.

Password (Script) = The password will be located in the /deploy/<orchestrator>/central-deploy/password.txt folder for the script install.

• Make
• Go
• Vari linter Go che possono essere installati usando make reinstall-dev-tools.
• Strumenti di build UI come specificato in ui/README.md.
• Docker
  • Nota: Docker Desktop ora richiede un abbonamento a pagamento per le aziende di grandi dimensioni.
  • Alcuni sviluppatori di StackRox raccomandano Colima
• Strumenti da riga di comando Xcode (solo macOS)
• Bats viene utilizzato per eseguire alcuni test di shell. Puoi ottenerlo con brew install bats o npm install -g bats.
• oc strumento CLI OpenShift
• shellcheck per il linting degli script shell.

Xcode - macOS Only

Di solito li avresti già installati tramite brew. Tuttavia, se ricevi un errore durante la creazione di golang x/tools, prova prima ad assicurarti che il contratto di licenza sia stato accettato:

1. avviando Xcode
2. creando un nuovo progetto di app vuoto
3. avviando l'app del progetto vuoto nell'emulatore
4. chiudi sia l'emulatore che Xcode, poi
5. esegui i seguenti comandi: ```bash xcode-select --install sudo xcode-select --switch /Library/Developer/CommandLineTools # Enable command line tools sudo xcode-select -s /Applications/Xcode.app/Contents/Developer

Per maggiori informazioni, vedere <https://github.com/nodejs/node-gyp/issues/569>

</details>

#### Clonare StackRox
<details><summary>Clicca per espandere</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

Nota: Docker Desktop e Colima sono più adatti per lo sviluppo su macOS, perché il cluster avrà accesso alle immagini costruite con make image localmente senza ulteriore configurazione. Inoltre, Collector ha un supporto migliore per questi rispetto a minikube, dove i driver potrebbero non essere disponibili.```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

Vedi [Installazione tramite script](#installation-via-scripts) per ulteriori letture. Per saperne di più sulle variabili d'ambiente, consulta
[deploy/README.md](https://github.com/stackrox/stackrox/blob/master/deploy/README.md#env-variables).

</details>

#### Obiettivi comuni del Makefile

<details><summary>Clicca per espandere</summary>```bash
# Build image, this will create `stackrox/main` with a tag defined by `make tag`.
$ make image

# 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

Il repository del workflow contiene alcuni script di supporto che facilitano il nostro flusso di lavoro di sviluppo. Esplora altri comandi con 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 # 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.

</details>

#### Configurazione di GoLand

<details><summary>Clicca per espandere</summary>

Se stai usando GoLand per lo sviluppo, quanto segue può aiutare a migliorare l'esperienza.

Assicurati che il plugin `Protocol Buffers` sia installato. Il plugin è installato per impostazione predefinita in GoLand.
Se non lo è, usa `Help | Find Action...`, digita `Plugins` e premi Invio, quindi passa a `Marketplace`, digita il suo nome e installa il plugin.

Questo plugin non sa dove cercare le importazioni `.proto` per impostazione predefinita in GoLand, quindi devi configurare esplicitamente i percorsi per questo plugin. Vedi <https://github.com/jvolkman/intellij-protobuf-editor#path-settings>.

* Vai a `GoLand | Preferences | Languages & Frameworks | Protocol Buffers`.
* Deseleziona `Configure automatically`.
* Clicca sul pulsante `+`, naviga e seleziona la directory `./proto` nella radice del repository.
* Opzionalmente, aggiungi anche `$HOME/go/pkg/mod/github.com/gogo/[email protected]`
  e `$HOME/go/pkg/mod/github.com/gogo/[email protected]/`.
* Per verificare: usa il menu `Navigate | File...` digita un nome di file `.proto`, ad esempio `alert_service.proto`, e controlla che tutte le stringhe di import siano mostrate in verde, non in rosso.

</details>

#### Esecuzione dei test sql_integration

<details><summary>Clicca per espandere</summary>

I test Go annotati con `//go:build sql_integration` richiedono un server PostgreSQL in ascolto sulla porta 5432.
A causa di come è configurata l'autenticazione nel codice, il modo più semplice è avviare Postgres in un contenitore in questo modo:```bash
$ docker run --rm --env POSTGRES_USER="$USER" --env POSTGRES_HOST_AUTH_METHOD=trust --publish 5432:5432 docker.io/library/postgres:15

Con ciò in esecuzione in background, i test sql_integration possono essere attivati dall'IDE o dalla riga di comando.

Configurazione del debugger per Kubernetes

Con GoLand, puoi naturalmente utilizzare breakpoint e il debugger quando esegui test unitari nell'IDE.

Se desideri eseguire il debug di un deployment locale o anche remoto, segui la procedura qui sotto.

1. Crea un build di debug localmente esportando DEBUG_BUILD=yes: ```bash $ DEBUG_BUILD=yes make image
   root@kitploit:~

In alternativa, la build di debug verrà creata anche quando il nome del ramo contiene la sottostringa -debug. Questo funziona localmente con make image e in CI. 2. Distribuire l'immagine utilizzando le istruzioni presenti in questo file README. Funziona sia con deploy-local.sh che con deploy.sh. 3. Avviare il debugger (e il port forwarding) nel pod target utilizzando il comando roxdebug dal repository workflow. ```bash

For Central

$ roxdebug

For Sensor

$ roxdebug deploy/sensor

See usage help

$ roxdebug --help

4. Configura GoLand per il debug remoto (dovrebbe essere fatto solo una volta):
 1. Apri `Run | Edit Configurations …`, clicca sull'icona `+` per aggiungere una nuova configurazione, scegli il modello `Go Remote`.
 2. Scegli `Host:` `localhost` e `Port:` `40000`. Dai un nome a questa configurazione.
 3. Seleziona `On disconnect:` `Leave it running` (questo impedisce a GoLand di dimenticare i breakpoint alla riconnessione).
5. Collega GoLand alla porta di debug: seleziona `Run | Debug…` e scegli la configurazione che hai creato.
Se tutto è stato fatto correttamente, dovresti vedere il messaggio `Connected` nella finestra `Debug | Debugger | Variables` nella parte inferiore
dello schermo.
6. Imposta alcuni breakpoint del codice, attiva le azioni corrispondenti e buon debugging!

Vedi [Debug del codice Go in esecuzione in Kubernetes](https://github.com/stackrox/dev-docs/blob/main/docs/knowledge-base/%5BBE%5D%20Debugging-go-code-running-in-Kubernetes.md) per
maggiori informazioni.
</details>

## Generazione di Installer Portatili

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

Questo ti guiderà attraverso un programma di installazione e genererà un file k8s.zip.```bash unzip k8s.zip -d k8s

.```bash
bash k8s/central.sh

Ora Central è stato distribuito. Utilizza l'interfaccia utente per distribuire Sensor.

Nota: Se si utilizza un mount host, è necessario consentire al contenitore di accedervi utilizzando sudo chcon -Rt svirt_sandbox_file_t <full volume path>

Prendi lo script image-setup.sh da questo repository ed eseguilo per effettuare il pull/push sul registro OpenShift locale. Questo è un prerequisito per ogni nuovo cluster.```bash bash image-setup.sh

Inizializza il bootloader, imposta la memoria e passa dalla modalità protetta a 32 bit alla modalità long a 64 bit.```bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > openshift.zip

Questo ti guiderà attraverso un installatore e genererà un file openshift.zip.```bash unzip openshift.zip -d openshift

[No content provided in the input.]```bash
bash openshift/central.sh

Le seguenti informazioni sono state raccolte per aiutare con l'installazione e il funzionamento del progetto open source StackRox. Queste raccomandazioni sono state sviluppate per il prodotto Red Hat Advanced Cluster Security for Kubernetes e non sono state testate con il progetto upstream StackRox.

Distribuzioni Kubernetes Raccomandate

Le piattaforme Kubernetes su cui StackRox è stato distribuito con problemi minimi sono elencate di seguito.

• 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)

Se si distribuisce su una distribuzione Kubernetes diversa da quelle elencate sopra, si potrebbero incontrare problemi.

Sistemi Operativi Raccomandati

StackRox è noto per funzionare sulle versioni recenti dei seguenti sistemi operativi.

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

Browser Web Raccomandati

La seguente tabella elenca i browser che possono visualizzare l'interfaccia utente web di StackRox.

• Google Chrome 88.0 (64-bit)
• Microsoft Internet Explorer Edge
  • Versione 44 e successive (Windows)
  • Versione 81 (build ufficiale) (64-bit)
• Safari su macOS (Mojave) - Versione 14.0
• Mozilla Firefox Versione 82.0.2 (64-bit)