Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Installa il sensore di runtime Wiz nei cluster GKE

Autopilot Standard

Wiz Runtime Sensor è un componente della piattaforma principale di Wiz che fornisce funzionalità di rilevamento e risposta alle minacce in tempo reale per i workload di runtime. Puoi installare Runtime Sensor nei cluster Google Kubernetes Engine (GKE) come componente aggiuntivo gestito. Questo documento mostra agli amministratori della piattaforma e agli ingegneri della sicurezza come installare il componente aggiuntivo Runtime Sensor, configurare l'accesso alla piattaforma Wiz e applicare l'installazione di Runtime Sensor nell'organizzazione, nella cartella o nel progetto.

Dovresti già conoscere il Wiz Runtime Sensor.

Quando utilizzare il componente aggiuntivo Runtime Sensor

Il metodo di installazione del componente aggiuntivo gestito è un'alternativa integrata all'installazione di Runtime Sensor utilizzando metodi di installazione come un grafico Helm. Il componente aggiuntivo Runtime Sensor offre i seguenti vantaggi:

GKE installa i componenti e gestisce la maggior parte delle attività di configurazione, riducendo l'impegno e la complessità dell'installazione di Runtime Sensor rispetto all'utilizzo del grafico Helm.
Puoi utilizzare il servizio Policy dell'organizzazione per richiedere l'abilitazione del componente aggiuntivo nell'organizzazione, nelle cartelle o nei progetti.
Il componente aggiuntivo viene eseguito nei cluster Autopilot e insieme ai workload Autopilot nei cluster Standard senza richiedere l'aggiunta di Runtime Sensor a una lista consentita.
Gli aggiornamenti dei componenti di Runtime Sensor sono indipendenti dagli upgrade della versione della patch GKE.

Puoi anche installare Runtime Sensor nei cluster utilizzando il grafico Helm. Se utilizzi questo metodo, hai maggiore flessibilità per personalizzare la configurazione del sensore. Tuttavia, questo metodo richiede una configurazione manuale più complessa durante l'installazione ed è più difficile da applicare su larga scala rispetto all'utilizzo del componente aggiuntivo. Se installi Runtime Sensor utilizzando il grafico Helm, i componenti non vengono gestiti da GKE. Se non utilizzi il componente aggiuntivo GKE, segnala eventuali problemi con Runtime Sensor, come errori o incompatibilità, direttamente a Wiz.

Come funziona

Installa il componente aggiuntivo in cluster specifici utilizzando l'API GKE. Quando abiliti il componente aggiuntivo, GKE crea lo spazio dei nomi gke-managed-wiz e installa i componenti di Runtime Sensor. GKE richiede l'accesso al Container Registry privato di Wiz per eseguire il pull delle immagini per Runtime Sensor.

Dopo l'installazione, Runtime Sensor richiede l'accesso all'API Wiz per inviare informazioni alla piattaforma Wiz. Per concedere a GKE e Runtime Sensor l'accesso richiesto, fornisci le seguenti informazioni come secret nello spazio dei nomi gke-managed-wiz:

Credenziali per accedere al Container Registry di Wiz ed eseguire il pull dell'immagine di Runtime Sensor.
Informazioni di configurazione per Runtime Sensor, come le credenziali dell'API Wiz e le variabili specifiche dell'ambiente.

Puoi creare questi secret manualmente o caricare le informazioni in Google Cloud Secret Manager, che crea automaticamente i secret, ruota le versioni in base a una pianificazione ricorrente ed esegue il deployment degli aggiornamenti dei secret.

Prezzi

Il componente aggiuntivo Wiz Runtime Sensor è disponibile senza costi aggiuntivi in GKE. Si applicano le seguenti considerazioni:

Devi avere una licenza Wiz Runtime Sensor attiva. Per ulteriori informazioni, consulta la pagina Prezzi di Wiz.
I componenti di Runtime Sensor vengono eseguiti sui nodi e consumano risorse di CPU e memoria, il che potrebbe comportare la necessità di un numero maggiore di nodi per ospitare tutti i pod nel cluster.
Se utilizzi Secret Manager per archiviare le credenziali e le configurazioni di Wiz, si applicano i prezzi di Secret Manager.

Limitazioni

L'utilizzo del componente aggiuntivo è soggetto alle seguenti limitazioni:

Se aggiorni le credenziali dell'API o del registro Wiz nei secret di cui è stato eseguito il deployment, devi riavviare manualmente il DaemonSet di Runtime Sensor utilizzando il comando kubectl rollout restart.
Per installare Runtime Sensor, devi caricare le credenziali del registro del tenant come secret Kubernetes o in Secret Manager.
Se utilizzi nodi privati, devi configurare l'accesso in uscita a l registro container di Wiz (registry.wiz.io) utilizzando Cloud NAT.
Il componente aggiuntivo GKE gestito supporta solo i seguenti parametri di configurazione facoltativi per Runtime Sensor:
- httpProxyConfiguration.httpsProxy
- httpProxyConfiguration.caCertificate
- httpProxyConfiguration.clientCertificate

Per utilizzare uno degli altri parametri di configurazione, installa Runtime Sensor utilizzando il grafico Helm.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI assicurati di impostare la compute/region proprietà. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Crea un cluster Autopilot o un cluster Standard con Workload Identity Federation per GKE abilitato ed esegui GKE versione 1.36.4-gke.1495000 o successive.

Ruoli obbligatori

Per abilitare e configurare il componente aggiuntivo Runtime Sensor per GKE, devi disporre dei seguenti ruoli nel Google Cloud progetto:

Configura i cluster GKE: Kubernetes Engine Cluster Admin (roles/container.clusterAdmin) nel Google Cloud progetto.
Carica le credenziali API e i file di configurazione in Secret Manager: Secret Manager Editor (roles/secretmanager.editor) nel Google Cloud progetto.
Concedi i ruoli IAM (Identity and Access Management) al service account Kubernetes utilizzato da Runtime Sensor: Secret Manager Admin (roles/secretmanager.admin) nel Google Cloud progetto.
Configura una policy dell'organizzazione: Organization Policy Administrator (roles/orgpolicy.policyAdmin) nella tua organizzazione.

Devi anche avere accesso a un tenant Wiz per ottenere le credenziali per il Container Registry di Wiz e generare un token OAuth per l'API Wiz.

Prepara le credenziali e i file di configurazione di Wiz

Per installare Runtime Sensor e inviare informazioni alla piattaforma Wiz, devi fornire le credenziali per accedere al registro privato di Wiz e all'API Wiz. Per preparare queste informazioni, segui questi passaggi:

Trova le credenziali del Container Registry di Wiz per il registry.wiz.io registro.
Crea una stringa con codifica in base64 che contenga le credenziali del registro in una struttura che Kubernetes possa analizzare:
```
echo -n 'WIZ_REGISTRY_USERNAME:WIZ_REGISTRY_PASSWORD' | base64 | tr -d '\n'
```
Sostituisci quanto segue:
- WIZ_REGISTRY_USERNAME: il nome utente per il Container Registry di Wiz.
- WIZ_REGISTRY_PASSWORD: la password per il Container Registry di Wiz.
L'output è simile al seguente:
```
aGVsbG86d29ybGQ=
```

Salva le informazioni come file JSON:

{
  "auths": {
    "registry.wiz.io": {
      "username": "WIZ_REGISTRY_USERNAME",
      "password": "WIZ_REGISTRY_PASSWORD",
      "auth": "BASE64_ENCODED_CREDENTIALS"
    }
  }
}

Sostituisci BASE64_ENCODED_CREDENTIALS con la stringa codificata del passaggio precedente.

Crea un service account Wiz e copia le seguenti informazioni:
- L'ID client, che puoi trovare anche nel portale Wiz nella pagina Service account.
- Il client secret, visibile solo quando crei il service account.
Crea un file di configurazione YAML per Runtime Sensor:
```
clientId: "WIZ_CLIENT_ID"
clientToken: "WIZ_CLIENT_SECRET"
clientEndpoint: "WIZ_CLIENT_ENDPOINT"
```
Sostituisci quanto segue:
- WIZ_CLIENT_ID: l'ID client del service account.
- WIZ_CLIENT_TOKEN: il client secret del service account.
- WIZ_CLIENT_ENDPOINT: l'URL del token da utilizzare, che dipende dal tenant Wiz.
(Facoltativo) Se utilizzi un proxy HTTP, puoi configurare Runtime Sensor in modo che utilizzi il server proxy. Crea un file di configurazione YAML per il proxy:
```
httpsProxy: "PROXY_URL"
caCertificate: "CA_CERTIFICATE"
clientCertificate: "CLIENT_CERTIFICATE"
```
Sostituisci quanto segue:
- PROXY_URL: l'URL del proxy completo, ad esempio https://proxy.example.com:8080.
- CA_CERTIFICATE: il certificato CA del server proxy in formato PEM. Se il server proxy non utilizza TLS, allora specifica un valore vuoto ("").
- CLIENT_CERTIFICATE: il certificato client del server proxy in formato PEM. Se il server proxy non utilizza TLS, specifica un valore vuoto ("").

Crea secret in Secret Manager

Questa sezione mostra come archiviare i vari file di configurazione e credenziali di Wiz in Secret Manager. Puoi specificare gli URI di questi secret quando abiliti il componente aggiuntivo Runtime Sensor in un cluster GKE. Secret Manager crea automaticamente i secret Kubernetes nello spazio dei nomi Wiz. Quando aggiorni i valori in Secret Manager, i secret Kubernetes vengono sincronizzati automaticamente per utilizzare i nuovi valori. Facoltativamente, puoi saltare questa sezione e creare manualmente i secret nello spazio dei nomi gke-managed-wiz.

Per creare i secret in Secret Manager, segui questi passaggi:

Archivia le credenziali del registro Wiz:
1. Crea un secret per archiviare le credenziali del registro Wiz:
```
gcloud secrets create wiz-image-pull-secret \
    --replication-policy="automatic" \
    --project="SECRET_PROJECT_ID"
```
  Sostituisci SECRET_PROJECT_ID con l'ID progetto del Google Cloud progetto in cui creare i secret.
2. Archivia le credenziali del registro Wiz nel secret wiz-image-pull-secret:
```
gcloud secrets versions add wiz-image-pull-secret \
    --project="SECRET_PROJECT_ID" \
    --data-file=PATH_TO_CREDENTIALS_FILE
```
  Sostituisci PATH_TO_CREDENTIALS_FILE con il percorso del file JSON che contiene le credenziali del registro Wiz.
Archivia le credenziali dell'API Runtime Sensor:
1. Crea un secret per archiviare le credenziali dell'API Runtime Sensor:
```
gcloud secrets create wiz-api-key-secret \
    --replication-policy="automatic" \
    --project="SECRET_PROJECT_ID"
```
2. Archivia le credenziali dell'API Runtime Sensor nel secret wiz-api-key-secret:
```
gcloud secrets versions add wiz-api-key-secret \
    --project="SECRET_PROJECT_ID" \
    --data-file=PATH_TO_CONFIG_FILE
```
  Sostituisci PATH_TO_CONFIG_FILE con il percorso del file YAML che contiene le credenziali dell'API Runtime Sensor.
(Facoltativo) Archivia le informazioni di configurazione per il proxy:
1. Crea un secret per archiviare la configurazione del server proxy:
```
gcloud secrets create wiz-sensor-proxy-secret \
    --replication-policy="automatic" \
    --project="SECRET_PROJECT_ID"
```
2. Archivia la configurazione del server proxy nel secret wiz-sensor-proxy-secret:
```
gcloud secrets versions add wiz-sensor-proxy-secret \
    --project="SECRET_PROJECT_ID" \
    --data-file=PATH_TO_PROXY_FILE
```
  Sostituisci PATH_TO_PROXY_FILE con il percorso del file YAML che contiene i parametri di configurazione del proxy.

Concedi a GKE l'accesso a Secret Manager

Per sincronizzare le informazioni in Secret Manager come secret Kubernetes, concedi il ruolo IAM Secret Manager Secret Accessor (roles/secretmanager.secretAccessor) ai secret che hai creato al service account Kubernetes wiz-sensor-secretsync-sa nello spazio dei nomi gke-managed-wiz. Quando abiliti il componente aggiuntivo Runtime Sensor in un cluster, GKE crea questo service account e utilizza la sua identità per creare i secret corrispondenti nello spazio dei nomi. Se prevedi di creare manualmente i secret anziché utilizzare Secret Manager, salta questa sezione.

I passaggi seguenti mostrano come concedere il ruolo richiesto:

Trova il numero di progetto del progetto del cluster:
```
gcloud projects describe CLUSTER_PROJECT_ID --format='value(projectNumber)'
```
L'output è simile a 1234567890.

Concedi il ruolo al secret wiz-image-pull-secret:

gcloud secrets add-iam-policy-binding wiz-image-pull-secret \
    --project=SECRET_PROJECT_ID \
    --role="roles/secretmanager.secretAccessor" \
    --member="principal://iam.googleapis.com/projects/CLUSTER_PROJECT_NUMBER/locations/global/workloadIdentityPools/CLUSTER_PROJECT_ID.svc.id.goog/subject/ns/gke-managed-wiz/sa/wiz-sensor-secretsync-sa"

Sostituisci quanto segue:

SECRET_PROJECT_ID: l'ID progetto del progetto che contiene i secret.
CLUSTER_PROJECT_NUMBER: il numero di progetto del progetto del cluster.
CLUSTER_PROJECT_ID: l'ID progetto del progetto del cluster.

Concedi il ruolo al secret wiz-api-key-secret:

gcloud secrets add-iam-policy-binding wiz-api-key-secret \
    --project=SECRET_PROJECT_ID \
    --role="roles/secretmanager.secretAccessor" \
    --member="principal://iam.googleapis.com/projects/CLUSTER_PROJECT_NUMBER/locations/global/workloadIdentityPools/CLUSTER_PROJECT_ID.svc.id.goog/subject/ns/gke-managed-wiz/sa/wiz-sensor-secretsync-sa"

(Facoltativo) Se hai creato un secret che contiene informazioni sul proxy HTTP, concedi il ruolo al secret wiz-sensor-proxy-secret:

gcloud secrets add-iam-policy-binding wiz-sensor-proxy-secret \
    --project=SECRET_PROJECT_ID \
    --role="roles/secretmanager.secretAccessor" \
    --member="principal://iam.googleapis.com/projects/CLUSTER_PROJECT_NUMBER/locations/global/workloadIdentityPools/CLUSTER_PROJECT_ID.svc.id.goog/subject/ns/gke-managed-wiz/sa/wiz-sensor-secretsync-sa"

Abilita il componente aggiuntivo Runtime Sensor per GKE

Dopo aver creato i secret in Secret Manager e aver concesso a GKE il ruolo richiesto per i secret, abilita il componente aggiuntivo Runtime Sensor per il cluster. Puoi abilitare il componente aggiuntivo nei cluster Standard o Autopilot nuovi o esistenti. I passaggi seguenti mostrano come abilitare il componente aggiuntivo e configurare la sincronizzazione dei secret in un cluster esistente. Puoi utilizzare questi flag anche durante la creazione del cluster.

Abilita la sincronizzazione dei secret per un cluster esistente. Se prevedi di creare manualmente i secret anziché utilizzare Secret Manager, salta questo passaggio.
```
gcloud container clusters update CLUSTER_NAME \
    --project=CLUSTER_PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --enable-secret-sync --enable-secret-sync-rotation
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CLUSTER_PROJECT_ID: l'ID progetto del progetto del cluster.
- CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.

Abilita il componente aggiuntivo eseguendo uno dei seguenti comandi. Se prevedi di creare manualmente i secret anziché utilizzare Secret Manager, specifica solo il flag --addons in questi comandi.

Abilita il componente aggiuntivo senza configurare un proxy HTTP:

gcloud container clusters update CLUSTER_NAME \
    --project=CLUSTER_PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --update-addons=WizSensor=ENABLED \
    --wiz-sensor-registry-secret-uri=projects/SECRET_PROJECT_ID/secrets/wiz-image-pull-secret/versions/latest \
    --wiz-sensor-api-key-secret-uri=projects/SECRET_PROJECT_ID/secrets/wiz-api-key-secret/versions/latest

Abilita il componente aggiuntivo e configura un proxy HTTP:

gcloud container clusters update CLUSTER_NAME \
    --project=CLUSTER_PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --update-addons=WizSensor=ENABLED \
    --wiz-sensor-registry-secret-uri=projects/SECRET_PROJECT_ID/secrets/wiz-image-pull-secret/versions/latest \
    --wiz-sensor-api-key-secret-uri=projects/SECRET_PROJECT_ID/secrets/wiz-api-key-secret/versions/latest \
    --wiz-sensor-proxy-secret-uri=projects/SECRET_PROJECT_ID/secrets/wiz-sensor-proxy-secret/versions/latest

Verifica l'installazione

Per verificare l'installazione del componente aggiuntivo:

Ottieni le credenziali per eseguire i comandi kubectl nel cluster:

gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --project=CLUSTER_PROJECT_ID

Controlla se esiste lo spazio dei nomi gke-managed-wiz:

kubectl get namespace gke-managed-wiz