Pour voir tous les Helm charts disponibles dans le repo, exécutez (vous pouvez ajouter l'option `--devel` pour afficher également les versions non publiées)```sh
helm search repo stackrox

À partir de là, vous pouvez installer stackrox-central-services pour déployer les composants Central et Scanner sur votre cluster.

> **Remarque:**
> Vous n'avez besoin que d'une seule instance déployée de stackrox-central-services, même si vous prévoyez de sécuriser plusieurs clusters.

#### Installation par défaut de Central

Si vous installez dans un cluster de taille raisonnable, utilisez la commande d'installation par défaut :```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"

</details>

<details><summary>Installer les services de cluster sécurisé StackRox</summary>

Ensuite, le composant de cluster sécurisé devra être déployé pour collecter des informations depuis les nœuds Kubernetes.

Définissez un nom de cluster significatif pour votre cluster sécurisé dans la variable shell `CLUSTER_NAME`. Le cluster sera identifié par ce nom dans la liste des clusters de l'interface utilisateur StackRox.```sh
CLUSTER_NAME="my-secured-cluster"

Générez un bundle d'initialisation contenant les secrets d'initialisation. Le bundle d'initialisation sera sauvegardé dans `stackrox-init-bundle.yaml` et vous l'utiliserez pour provisionner des clusters sécurisés comme indiqué ci-dessous.```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

#### Installation des services de cluster sécurisés dans les clusters aux ressources limitées

Si vous installez dans un cluster à nœud unique, ou si l'installation par défaut entraîne le blocage de pods en attente par manque de ressources, utilisez plutôt la commande suivante pour réduire les besoins en ressources de stackrox-secured-cluster-services. Gardez à l'esprit que ces paramètres de ressources réduits ne conviennent pas à un environnement de production.```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

Après quelques minutes, toutes les ressources devraient être déployées.

**Les identifiants pour l'utilisateur 'admin' se trouvent dans le fichier `./deploy/k8s/central-deploy/password`.**

> **Remarque :**
> Le fichier de mot de passe est stocké en clair sur votre système de fichiers local, mais le Secret Kubernetes que StackRox crée à partir de celui-ci est chiffré. Vous ne pourrez pas modifier le mot de passe au moment de l'exécution. Si vous perdez le mot de passe, vous devrez redéployer central.

</details>

#### OpenShift

<details><summary>Cliquez pour développer</summary>

Avant de déployer sur OpenShift, assurez-vous d'avoir installé [oc - OpenShift Command Line](https://github.com/openshift/oc).

Suivez le guide ci-dessous pour déployer rapidement une version spécifique de StackRox sur votre cluster OpenShift dans l'espace de noms `stackrox`. Assurez-vous d'ajouter le tag le plus récent à la variable `MAIN_IMAGE_TAG`.

Exécutez ce qui suit dans le répertoire de travail de votre choix :```
git clone [email protected]:stackrox/stackrox.git
cd stackrox
MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Après quelques minutes, toutes les ressources devraient être déployées.

**Les informations d'identification pour l'utilisateur 'admin' se trouvent dans le fichier `./deploy/k8s/deploy-local/password`.**

</details>

## Accéder à l'interface utilisateur StackRox (UI)

<details><summary>Cliquez pour développer</summary>

Après le déploiement terminé (installation par opérateur, Helm ou script), un transfert de port devrait exister, afin que vous puissiez vous connecter à https://localhost:8000/. Exécutez ce qui suit```sh
kubectl port-forward -n 'stackrox' svc/central "8000:443"

Pour plus d'infos, voir <https://github.com/nodejs/node-gyp/issues/569>

</details>

#### Cloner StackRox
<details><summary>Cliquez pour déplier</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

Maintenant, vous devez démarrer un cluster Kubernetes *vous-même* avant de continuer.
Le développement peut se faire dans GCP ou localement avec
[Docker Desktop](https://docs.docker.com/desktop/kubernetes/), [Colima](https://github.com/abiosoft/colima#kubernetes), [minikube](https://minikube.sigs.k8s.io/docs/start/).

> **Remarque :**
> Docker Desktop et Colima sont plus adaptés au développement sur macOS, car le cluster aura accès aux images construites avec `make image` localement sans configuration supplémentaire. De plus, Collector a un meilleur support pour ceux-ci que minikube où les pilotes peuvent ne pas être disponibles.```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

</details>

#### Productivité

<details><summary>Cliquez pour développer</summary>

Le [dépôt workflow](https://github.com/stackrox/workflow) contient quelques scripts d'aide
qui soutiennent notre flux de développement. Découvrez plus de commandes avec `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.

Avec cela tournant en arrière-plan, les tests `sql_integration` peuvent être déclenchés depuis l'IDE ou la ligne de commande.

</details>

#### Débogage

<details><summary>Cliquez pour développer</summary>

**Configuration du débogueur Kubernetes**

Avec GoLand, vous pouvez naturellement utiliser les points d'arrêt et le débogueur lors de l'exécution de tests unitaires dans l'IDE.

Si vous souhaitez déboguer un déploiement local ou même distant, suivez la procédure ci-dessous.

1. Créez une build de débogage localement en exportant `DEBUG_BUILD=yes`:   ```bash
   $ DEBUG_BUILD=yes make image

4. Configurez GoLand pour le débogage à distance (à faire une seule fois) :
 1. Ouvrez `Run | Edit Configurations …`, cliquez sur l'icône `+` pour ajouter une nouvelle configuration, choisissez le modèle `Go Remote`.
 2. Choisissez `Host:` `localhost` et `Port:` `40000`. Donnez un nom à cette configuration.
 3. Sélectionnez `On disconnect:` `Leave it running` (cela empêche GoLand d'oublier les points d'arrêt lors de la reconnexion).
5. Attachez GoLand au port de débogage : sélectionnez `Run | Debug…` et choisissez la configuration que vous avez créée.
Si tout est fait correctement, vous devriez voir le message `Connected` dans la fenêtre `Debug | Debugger | Variables` en bas
de l'écran.
6. Définissez quelques points d'arrêt dans le code, déclenchez les actions correspondantes et bon débogage !

Voir [Débogage de code Go exécuté dans Kubernetes](https://github.com/stackrox/dev-docs/blob/main/docs/knowledge-base/%5BBE%5D%20Debugging-go-code-running-in-Kubernetes.md) pour
plus d'informations.
</details>

## Génération d'installateurs portables

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

--config string   Chemin vers le fichier de configuration (default "/workspace/config.json")
      --help            aide pour l'analyse
  clean
  conf
  dnspolution
  scan

### scan [flags] [domain]

Effectue une analyse sur le nom de domaine spécifié

### clean [flags]

Effectue un nettoyage

### conf [flags]

Affiche la configuration

### dnspolution [flags]

Effectue une attaque dnspolution sur le nom de domaine spécifié

Flags:
      --config string   Chemin vers le fichier de configuration (default "/workspace/config.json")
      --help            aide pour dnspolution

### help [command] [flags]

Affiche l'aide pour la commande donnée

Flags:
      --help   aide pour l'aide

### scan [flags] [domain]

Effectue une analyse sur le nom de domaine spécifié

Flags:
  -h, --help            aide pour l'analyse
      --full            Effectue une analyse complète (connect + gobuster/dirsearch)
      --help            aide pour l'analyse```bash
bash k8s/central.sh

Please provide the Markdown content to translate.```bash
docker run -i --rm quay.io/stackrox-io/main:<tag> central generate interactive > openshift.zip

Please provide the Markdown content to translate.```bash
bash openshift/central.sh