Questa pagina è stata tradotta dall'API Cloud Translation.

Crea risorse Google Cloud conformi ai criteri

Questo tutorial mostra come gli amministratori della piattaforma possono utilizzare i criteri di Policy Controller per controllare la creazione di risorse Google Cloud utilizzando Config Connector.

Questa pagina è destinata agli amministratori IT e agli operatori che vogliono assicurarsi che tutte le risorse in esecuzione all'interno della piattaforma cloud soddisfino i requisiti di conformità dell'organizzazione fornendo e gestendo l'automazione per il controllo o l'applicazione e che gestiscono il ciclo di vita dell'infrastruttura tecnologica sottostante. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti diGoogle Cloud , consulta Ruoli e attività comuni degli utenti di GKE Enterprise.

Le istruzioni di questo tutorial presuppongono che tu abbia una conoscenza di base di Kubernetes o Google Kubernetes Engine (GKE). Nel tutorial, definisci un criterio che limita le località consentite per i bucket Cloud Storage.

Policy Controller controlla, verifica e applica la conformità delle risorse del cluster Kubernetes a criteri relativi a sicurezza, normative o regole aziendali. Policy Controller è basato sul progetto open source OPA Gatekeeper.

Config Connector crea e gestisce il ciclo di vita delle Google Cloud risorse, descrivendole come risorse personalizzate di Kubernetes. Per creare una risorsa Google Cloud , crea una risorsa Kubernetes in uno spazio dei nomi gestito da Config Connector. Il seguente esempio mostra come descrivere un bucket Cloud Storage utilizzando Config Connector:

apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: my-bucket
spec:
  location: us-east1

Gestendo le risorse Google Cloud con Config Connector, puoi applicare i criteri di Policy Controller a queste risorse man mano che le crei nel cluster Google Kubernetes Engine (GKE) Enterprise. Queste policy ti consentono di impedire o segnalare azioni che creano o modificano risorse in modi che violano le tue policy. Ad esempio, puoi applicare un criterio che limita le località dei bucket Cloud Storage.

Questo approccio, basato sul modello di risorse Kubernetes (KRM), ti consente di utilizzare un insieme coerente di strumenti e flussi di lavoro per gestire sia Kubernetes sia le risorse Google Cloud . Questo tutorial mostra come completare le seguenti attività:

Definisci criteri che regolano le tue Google Cloud risorse.
Implementa controlli che impediscano a sviluppatori e amministratori di creare risorse Google Cloud che violano le tue norme.
Implementa controlli che eseguono l'audit delle risorse Google Cloud esistenti in base ai tuoi criteri, anche se hai creato queste risorse al di fuori di Config Connector.
Fornisci un feedback rapido a sviluppatori e amministratori durante la creazione e l'aggiornamento delle definizioni delle risorse.
Convalida le definizioni delle risorse Google Cloud in base ai tuoi criteri prima di tentare di applicarle a un cluster Kubernetes.

Obiettivi

Crea un cluster Google Kubernetes Engine (GKE) Enterprise che includa il componente aggiuntivo Config Connector.
Installa Policy Controller.
Crea un criterio per limitare le località dei bucket Cloud Storage consentite.
Verifica che il criterio impedisca la creazione di bucket Cloud Storage in località non consentite.
Valuta la conformità ai criteri della definizione del bucket Cloud Storage durante lo sviluppo.
Controlla la conformità alle norme dei bucket Cloud Storage esistenti.

Costi

In questo documento, utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Prima di iniziare

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell
In Cloud Shell, imposta il progetto Google Cloud che vuoi utilizzare per questo tutorial:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'Google Cloud ID progetto del tuo progetto. Quando esegui questo comando, Cloud Shell crea una variabile di ambiente esportata denominata GOOGLE_CLOUD_PROJECT che contiene il tuo ID progetto. Se non utilizzi Cloud Shell, puoi creare la variabile di ambiente con questo comando:
```
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value core/project)
```

Abilita l'API GKE:

gcloud services enable container.googleapis.com

Abilita l'API Policy Controller:

gcloud services enable anthospolicycontroller.googleapis.com

Crea una directory in cui archiviare i file creati per questo tutorial:
```
mkdir -p ~/cnrm-gatekeeper-tutorial
```
Vai alla directory che hai creato:
```
cd ~/cnrm-gatekeeper-tutorial
```

Crea un cluster GKE

In Cloud Shell, crea un cluster GKE con il componente aggiuntivo Config Connector e Workload Identity Federation for GKE:
```
gcloud container clusters create CLUSTER_NAME \
  --addons ConfigConnector \
  --enable-ip-alias \
  --num-nodes 4 \
  --release-channel regular \
  --scopes cloud-platform \
  --workload-pool $GOOGLE_CLOUD_PROJECT.svc.id.goog \
  --zone ZONE
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del cluster che vuoi utilizzare per questo progetto, ad esempio cnrm-gatekeeper-tutorial.
- ZONE: una zona Compute Engine vicina alla tua posizione, ad esempio asia-southeast1-b.
Il componente aggiuntivo Config Connector installa le definizioni di risorse personalizzate (CRD) per le risorseGoogle Cloud nel tuo cluster GKE.
(Facoltativo) Se utilizzi un cluster privato nel tuo ambiente, aggiungi una regola firewall che consenta al control plane del cluster GKE di connettersi al webhook di Policy Controller:
```
gcloud compute firewall-rules create allow-cluster-control-plane-tcp-8443 \
  --allow tcp:8443 \
  --network default \
  --source-ranges CONTROL_PLANE_CIDR \
  --target-tags NODE_TAG
```
Sostituisci quanto segue:
- CONTROL_PLANE_CIDR: l'intervallo IP per il control plane del cluster GKE, ad esempio 172.16.0.16/28.
- NODE_TAG: un tag applicato a tutti i nodi del cluster GKE.
Questa regola firewall facoltativa è necessaria per il funzionamento dell'webhook Policy Controller quando il cluster utilizza nodi privati.

Configura Config Connector

Il progetto Google Cloud in cui installi Config Connector è noto come progetto host. I progetti in cui utilizzi Config Connector per gestire le risorse sono noti come progetti gestiti. In questo tutorial, utilizzi Config Connector per creare risorseGoogle Cloud nello stesso progetto del tuo cluster GKE, in modo che il progetto host e il progetto gestito siano lo stesso progetto.

In Cloud Shell, crea un service account Google per Config Connector:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name "Config Connector Gatekeeper tutorial"
```
Sostituisci SERVICE_ACCOUNT_NAME con il nome che vuoi utilizzare per questo account di servizio, ad esempio cnrm-gatekeeper-tutorial. Config Connector utilizza questo account di servizio Google per creare risorse nel tuo progetto gestito.
Concedi il ruolo Amministratore storage all'account di servizio Google:
```
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member "serviceAccount:SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com" \
  --role roles/storage.admin
```
In questo tutorial utilizzi il ruolo Amministratore Storage perché utilizzi Config Connector per creare bucket Cloud Storage. Nel tuo ambiente, concedi i ruoli necessari per gestire le risorse Google Cloud che vuoi creare per Config Connector. Per saperne di più sui ruoli predefiniti, consulta la sezione Informazioni sui ruoli nella documentazione di IAM.
Crea uno spazio dei nomi Kubernetes per le risorse Config Connector che crei in questo tutorial:
```
kubectl create namespace NAMESPACE
```
Sostituisci NAMESPACE con lo spazio dei nomi Kubernetes che vuoi utilizzare nel tutorial, ad esempio tutorial.
Aggiungi un'annotazione allo spazio dei nomi per specificare il progetto che Config Connector deve utilizzare per creare Google Cloud risorse (il progetto gestito):
```
kubectl annotate namespace NAMESPACE \
    cnrm.cloud.google.com/project-id=$GOOGLE_CLOUD_PROJECT
```
Crea una risorsa ConfigConnectorContext che attiva Config Connector per lo spazio dei nomi Kubernetes e la associa al account di servizio Google che hai creato:
```
cat << EOF | kubectl apply -f -
apiVersion: core.cnrm.cloud.google.com/v1beta1
kind: ConfigConnectorContext
metadata:
  name: configconnectorcontext.core.cnrm.cloud.google.com
  namespace: NAMESPACE
spec:
  googleServiceAccount: SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
EOF
```
Quando crei la risorsa ConfigConnectorContext, Config Connector crea un service account Kubernetes e un StatefulSet nello spazio dei nomi cnrm-system per gestire le risorse Config Connector nel tuo spazio dei nomi.
Attendi il pod del controller Config Connector per il tuo spazio dei nomi:
```
kubectl wait --namespace cnrm-system --for=condition=Ready pod \
  -l cnrm.cloud.google.com/component=cnrm-controller-manager,cnrm.cloud.google.com/scoped-namespace=NAMESPACE
```
Quando il pod è pronto, viene visualizzato il prompt di Cloud Shell. Se ricevi il messaggio error: no matching resources found, attendi un minuto e riprova.
Collega account di servizio Kubernetes di Config Connector al tuo account di servizio Google creando un'associazione dei criteri IAM:
```
gcloud iam service-accounts add-iam-policy-binding \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
  --member "serviceAccount:$GOOGLE_CLOUD_PROJECT.svc.id.goog[cnrm-system/cnrm-controller-manager-NAMESPACE]" \
  --role roles/iam.workloadIdentityUser
```
Questa associazione consente al account di servizio Kubernetes cnrm-controller-manager-NAMESPACE nello spazio dei nomi cnrm-system di agire come service account Google che hai creato.

Installa Policy Controller

Installa Policy Controller seguendo le istruzioni di installazione.

Utilizza un intervallo di audit di 60 secondi.

Crea una risorsa Google Cloud utilizzando Config Connector

In Cloud Shell, crea un manifest Config Connector che rappresenti un bucket Cloud Storage nella regione us-central1:

cat << EOF > tutorial-storagebucket-us-central1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-us-central1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: us-central1
  uniformBucketLevelAccess: true
EOF

Per creare il bucket Cloud Storage, applica il manifest:

kubectl apply -f tutorial-storagebucket-us-central1.yaml

Verifica che Config Connector abbia creato il bucket Cloud Storage:
```
gcloud storage ls | grep tutorial
```
L'output è simile al seguente:
```
gs://tutorial-us-central1-PROJECT_ID/
```
Questo output include PROJECT_ID, che è l'ID progetto Google Cloud .

Se non vedi questo output, attendi un minuto ed esegui di nuovo il passaggio.

Crea un criterio

Un criterio in Policy Controller è costituito da un modello di vincolo e da un vincolo. Il modello di vincolo contiene la logica dei criteri. Il vincolo specifica dove si applica il criterio e i parametri di input alla logica del criterio.

In Cloud Shell, crea un modello di vincolo che limiti le posizioni dei bucket Cloud Storage:

cat << EOF > tutorial-storagebucket-location-template.yaml
apiVersion: templates.gatekeeper.sh/v1beta1
kind: ConstraintTemplate
metadata:
  name: gcpstoragelocationconstraintv1
spec:
  crd:
    spec:
      names:
        kind: GCPStorageLocationConstraintV1
      validation:
        openAPIV3Schema:
          properties:
            locations:
              type: array
              items:
                type: string
            exemptions:
              type: array
              items:
                type: string
  targets:
  - target: admission.k8s.gatekeeper.sh
    rego: |
      package gcpstoragelocationconstraintv1

      allowedLocation(reviewLocation) {
          locations := input.parameters.locations
          satisfied := [ good | location = locations[_]
                                good = lower(location) == lower(reviewLocation)]
          any(satisfied)
      }

      exempt(reviewName) {
          input.parameters.exemptions[_] == reviewName
      }

      violation[{"msg": msg}] {
          bucketName := input.review.object.metadata.name
          bucketLocation := input.review.object.spec.location
          not allowedLocation(bucketLocation)
          not exempt(bucketName)
          msg := sprintf("Cloud Storage bucket <%v> uses a disallowed location <%v>, allowed locations are %v", [bucketName, bucketLocation, input.parameters.locations])
      }

      violation[{"msg": msg}] {
          not input.parameters.locations
          bucketName := input.review.object.metadata.name
          msg := sprintf("No permitted locations provided in constraint for Cloud Storage bucket <%v>", [bucketName])
      }
EOF

Applica il modello per creare il bucket Cloud Storage:

kubectl apply -f tutorial-storagebucket-location-template.yaml

Crea un vincolo che consenta solo i bucket nelle regioni di Singapore e Giacarta (asia-southeast1 e asia-southeast2). Il vincolo si applica allo spazio dei nomi che hai creato in precedenza. Esenta il bucket Cloud Storage predefinito per Cloud Build.

cat << EOF > tutorial-storagebucket-location-constraint.yaml
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: GCPStorageLocationConstraintV1
metadata:
  name: singapore-and-jakarta-only
spec:
  enforcementAction: deny
  match:
    kinds:
    - apiGroups:
      - storage.cnrm.cloud.google.com
      kinds:
      - StorageBucket
    namespaces:
    - NAMESPACE
  parameters:
    locations:
    - asia-southeast1
    - asia-southeast2
    exemptions:
    - ${GOOGLE_CLOUD_PROJECT}_cloudbuild
EOF

Per limitare le zone in cui possono esistere i bucket, applica il vincolo:
```
kubectl apply -f tutorial-storagebucket-location-constraint.yaml
```

Verifica le norme

Crea un manifest che rappresenti un bucket Cloud Storage in una località non consentita (us-west1):

cat << EOF > tutorial-storagebucket-us-west1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-us-west1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: us-west1
  uniformBucketLevelAccess: true
EOF

Per creare il bucket Cloud Storage, applica il manifest:

kubectl apply -f tutorial-storagebucket-us-west1.yaml

L'output è simile al seguente:

Error from server ([singapore-and-jakarta-only] Cloud Storage bucket
<tutorial-us-west1-PROJECT_ID> uses a disallowed location
<us-west1>, allowed locations are ["asia-southeast1",
"asia-southeast2"]): error when creating
"tutorial-storagebucket-us-west1.yaml": admission webhook
"validation.gatekeeper.sh" denied the request: [singapore-and-jakarta-only]
Cloud Storage bucket <tutorial-us-west1-PROJECT_ID> uses a
disallowed location <us-west1>, allowed locations are
["asia-southeast1", "asia-southeast2"]

(Facoltativo) Puoi visualizzare un record della decisione di rifiuto della richiesta negli Cloud Audit Logs. Esegui una query sui log delle attività di amministrazione per il tuo progetto:

gcloud logging read --limit=1 \
    "logName=\"projects/$GOOGLE_CLOUD_PROJECT/logs/cloudaudit.googleapis.com%2Factivity\""'
    resource.type="k8s_cluster"
    resource.labels.cluster_name="CLUSTER_NAME"
    resource.labels.location="ZONE"
    protoPayload.authenticationInfo.principalEmail!~"system:serviceaccount:cnrm-system:.*"
    protoPayload.methodName:"com.google.cloud.cnrm."
    protoPayload.status.code=7'

L'output è simile al seguente:

insertId: 3c6940bb-de14-4d18-ac4d-9a6becc70828
labels:
  authorization.k8s.io/decision: allow
  authorization.k8s.io/reason: ''
  mutation.webhook.admission.k8s.io/round_0_index_0: '{"configuration":"mutating-webhook.cnrm.cloud.google.com","webhook":"container-annotation-handler.cnrm.cloud.google.com","mutated":true}'
  mutation.webhook.admission.k8s.io/round_0_index_1: '{"configuration":"mutating-webhook.cnrm.cloud.google.com","webhook":"management-conflict-annotation-defaulter.cnrm.cloud.google.com","mutated":true}'
logName: projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity
operation:
  first: true
  id: 3c6940bb-de14-4d18-ac4d-9a6becc70828
  last: true
  producer: k8s.io
protoPayload:
  '@type': type.googleapis.com/google.cloud.audit.AuditLog
  authenticationInfo:
    principalEmail: user@example.com
  authorizationInfo:
  - permission: com.google.cloud.cnrm.storage.v1beta1.storagebuckets.create
    resource: storage.cnrm.cloud.google.com/v1beta1/namespaces/NAMESPACE/storagebuckets/tutorial-us-west1-PROJECT_ID
  methodName: com.google.cloud.cnrm.storage.v1beta1.storagebuckets.create
  requestMetadata:
    callerIp: 203.0.113.1
    callerSuppliedUserAgent: kubectl/v1.21.1 (linux/amd64) kubernetes/5e58841
  resourceName: storage.cnrm.cloud.google.com/v1beta1/namespaces/NAMESPACE/storagebuckets/tutorial-us-west1-PROJECT_ID
  serviceName: k8s.io
  status:
    code: 7
    message: Forbidden
receiveTimestamp: '2021-05-21T06:56:24.940264678Z'
resource:
  labels:
    cluster_name: CLUSTER_NAME
    location: CLUSTER_ZONE
    project_id: PROJECT_ID
  type: k8s_cluster
timestamp: '2021-05-21T06:56:09.060635Z'

Il campo methodName mostra l'operazione tentata, il campo resourceName mostra il nome completo della risorsa Config Connector e la sezione status mostra che la richiesta non è andata a buon fine, con codice di errore 7 e messaggio Forbidden.

Crea un manifest che rappresenti un bucket Cloud Storage in una posizione consentita (asia-southeast1):

cat << EOF > tutorial-storagebucket-asia-southeast1.yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: tutorial-asia-southeast1-$GOOGLE_CLOUD_PROJECT
  namespace: NAMESPACE
spec:
  location: asia-southeast1
  uniformBucketLevelAccess: true
EOF

Per creare il bucket Cloud Storage, applica il manifest:

kubectl apply -f tutorial-storagebucket-asia-southeast1.yaml

L'output è simile al seguente:

storagebucket.storage.cnrm.cloud.google.com/tutorial-asia-southeast1-PROJECT_ID created

Questo output include PROJECT_ID, che è l'ID progetto Google Cloud .

Verifica che Config Connector abbia creato il bucket Cloud Storage:
```
gcloud storage ls | grep tutorial
```
L'output è simile al seguente:
```
gs://tutorial-asia-southeast1-PROJECT_ID/
gs://tutorial-us-central1-PROJECT_ID/
```
Se non vedi questo output, attendi un minuto ed esegui di nuovo questo passaggio.

Vincoli di controllo

Il controller di audit in Policy Controller valuta periodicamente le risorse in base ai relativi vincoli. Il controller rileva le violazioni dei criteri per le risorse create prima del vincolo e per le risorse create al di fuori di Config Connector.

In Cloud Shell, visualizza le violazioni per tutti i vincoli che utilizzano il modello di vincolo GCPStorageLocationConstraintV1:
```
kubectl get gcpstoragelocationconstraintv1 -o json \
  | jq '.items[].status.violations'
```
L'output è simile al seguente:
```
[
  {
    "enforcementAction": "deny",
    "kind": "StorageBucket",
    "message": "Cloud Storage bucket <tutorial-us-central1-PROJECT_ID>
    uses a disallowed location <us-central1>, allowed locations are
    \"asia-southeast1\", \"asia-southeast2\"",
    "name": "tutorial-us-central1-PROJECT_ID",
    "namespace": "NAMESPACE"
  }
]
```
Visualizzi il bucket Cloud Storage che hai creato in us-central1 prima di creare il vincolo.

Nota: l'attributo status.violations predefinito mostra fino a 20 violazioni per vincolo. Se il controller di controllo trova più di 20 violazioni dei vincoli, le restanti non vengono visualizzate. Se riscontri questa limitazione nel tuo ambiente, crea più vincoli. Assegna ogni vincolo a uno spazio dei nomi diverso.

Convalidare le risorse durante lo sviluppo

Durante lo sviluppo e le build di integrazione continua, è utile convalidare le risorse in base ai vincoli prima di applicarle al cluster GKE. La convalida fornisce un feedback rapido e ti consente di scoprire in anticipo i problemi relativi a risorse e vincoli. Questi passaggi mostrano come convalidare le risorse con kpt. Lo strumento a riga di comando kpt consente di gestire e applicare i manifest delle risorse Kubernetes.

In Cloud Shell, esegui la gatekeeper funzione KRM utilizzando kpt:

kpt fn eval . --image=gcr.io/kpt-fn/gatekeeper:v0.2 --truncate-output=false

Una funzione KRM è un programma che può modificare o convalidare le risorse Kubernetes memorizzate nel file system locale come file YAML. La funzione gatekeeper KRM convalida le risorse del bucket Cloud Storage di Config Connector in base al criterio Gatekeeper. La funzione gatekeeper KRM è pacchettizzata come immagine container disponibile in Artifact Registry.

La funzione segnala che i file manifest per i bucket Cloud Storage nelle regioni us-central1 e us-west1 violano il vincolo.

L'output è simile al seguente:

[RUNNING] "gcr.io/kpt-fn/gatekeeper:v0.2"
[FAIL] "gcr.io/kpt-fn/gatekeeper:v0.2"
  Results:
    [ERROR] Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-central1-GOOGLE_CLOUD_PROJECT" in file "tutorial-storagebucket-us-central1.yaml"
    [ERROR] Cloud Storage bucket <tutorial-us-west1-PROJECT_ID> uses a disallowed location <us-west1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-west1-GOOGLE_CLOUD_PROJECT" in file "tutorial-storagebucket-us-west1.yaml"
  Stderr:
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-central1-PROJECT_ID : Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-west1-PROJECT_IDT : Cloud Storage bucket <tutorial-us-west1-PROJECT_IDgt; uses a disallowed location <us-west1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
  Exit code: 1

Convalida le risorse create al di fuori di Config Connector

Puoi convalidare le risorse Google Cloud create al di fuori di Config Connector esportandole. Dopo aver esportato le risorse, utilizza una delle seguenti opzioni per valutare i criteri di Policy Controller rispetto alle risorse esportate:

Convalida le risorse utilizzando la funzione gatekeeper KRM.
Importa le risorse in Config Connector.

Per esportare le risorse, utilizza Cloud Asset Inventory.

In Cloud Shell, abilita l'API Cloud Asset:

gcloud services enable cloudasset.googleapis.com

Elimina i file manifest delle risorse Kubernetes per i bucket Cloud Storage in us-central1 e us-west1:
```
rm tutorial-storagebucket-us-*.yaml
```

Esporta tutte le risorse Cloud Storage nel progetto corrente e archivia l'output in un file denominato export.yaml:

gcloud beta resource-config bulk-export \
  --project $GOOGLE_CLOUD_PROJECT \
  --resource-format krm \
  --resource-types StorageBucket > export.yaml

L'output è simile al seguente:

Exporting resource configurations to stdout...

Export complete.

Crea una pipeline kpt concatenando le funzioni KRM. Questa pipeline convalida le risorse nella directory corrente in base al criterio di località del bucket Cloud Storage:

kpt fn source . \
  | kpt fn eval - --image=gcr.io/kpt-fn/set-namespace:v0.1 -- namespace=NAMESPACE \
  | kpt fn eval - --image=gcr.io/kpt-fn/gatekeeper:v0.2 --truncate-output=false

Le risorse esportate non hanno un valore per l'attributo dei metadati namespace. Questa pipeline utilizza una funzione KRM chiamata set-namespace per impostare il valore namespace di tutte le risorse.

L'output è simile al seguente e mostra le violazioni per le risorse che hai esportato:

[RUNNING] "gcr.io/kpt-fn/set-namespace:v0.1"
[PASS] "gcr.io/kpt-fn/set-namespace:v0.1"
[RUNNING] "gcr.io/kpt-fn/gatekeeper:v0.2"
[FAIL] "gcr.io/kpt-fn/gatekeeper:v0.2"
  Results:
    [ERROR] Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are ["asia-southeast1", "asia-southeast2"] violatedConstraint: singapore-and-jakarta-only in object "storage.cnrm.cloud.google.com/v1beta1/StorageBucket/tutorial/tutorial-us-central1-GOOGLE_CLOUD_PROJECT" in file "export.yaml"
  Stderr:
    "[error] storage.cnrm.cloud.google.com/v1beta1/StorageBucket/test/tutorial-us-central1-PROJECT_ID : Cloud Storage bucket <tutorial-us-central1-PROJECT_ID> uses a disallowed location <us-central1>, allowed locations are [\"asia-southeast1\", \"asia-southeast2\"]"
    "violatedConstraint: singapore-and-jakarta-only"
    ""
  Exit code: 1

Se il tuo progetto Google Cloud contiene bucket Cloud Storage che hai creato prima di seguire questo tutorial e la loro posizione viola il vincolo, i bucket creati in precedenza vengono visualizzati nell'output.

Congratulazioni, hai configurato correttamente un criterio che regola la posizione consentita dei bucket Cloud Storage. Il tutorial è stato completato. Ora puoi continuare ad aggiungere le tue norme per altre Google Cloud risorse.

Risoluzione dei problemi

Se Config Connector non crea le risorse Google Cloud previste, utilizza il seguente comando in Cloud Shell per visualizzare i log del gestore controller di Config Connector:

kubectl logs --namespace cnrm-system --container manager \
  --selector cnrm.cloud.google.com/component=cnrm-controller-manager,cnrm.cloud.google.com/scoped-namespace=NAMESPACE

Se Policy Controller non applica correttamente i criteri, utilizza il seguente comando per visualizzare i log di Controller Manager:

kubectl logs deployment/gatekeeper-controller-manager \
  --namespace gatekeeper-system

Se Policy Controller non segnala violazioni nel campo status degli oggetti vincolo, visualizza i log del controller di controllo utilizzando questo comando:

kubectl logs deployment/gatekeeper-audit --namespace gatekeeper-system

Se riscontri altri problemi con questo tutorial, ti consigliamo di consultare questi documenti:

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
If the project that you plan to delete is attached to an organization, expand the Organization list in the Name column.
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina le risorse

Se vuoi conservare il progetto Google Cloud che hai utilizzato in questo tutorial, elimina le singole risorse.

In Cloud Shell, elimina il vincolo di località del bucket Cloud Storage:
```
kubectl delete -f tutorial-storagebucket-location-constraint.yaml
```
Aggiungi l'annotazione cnrm.cloud.google.com/force-destroy con un valore stringa di true a tutte le risorse storagebucket nello spazio dei nomi gestito da Config Connector:
```
kubectl annotate storagebucket --all --namespace NAMESPACE \
  cnrm.cloud.google.com/force-destroy=true
```
Questa annotazione è una direttiva che consente a Config Connector di eliminare un bucket Cloud Storage quando elimini la risorsa storagebucket corrispondente nel cluster GKE, anche se il bucket contiene oggetti.
Elimina le risorse Config Connector che rappresentano i bucket Cloud Storage:
```
kubectl delete --namespace NAMESPACE storagebucket --all
```

Elimina il cluster GKE:

gcloud container clusters delete CLUSTER_NAME \
  --zone ZONE --async --quiet

Elimina l'associazione del criterio Workload Identity in IAM:

gcloud iam service-accounts remove-iam-policy-binding \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com \
  --member "serviceAccount:$GOOGLE_CLOUD_PROJECT.svc.id.goog[cnrm-system/cnrm-controller-manager-NAMESPACE]" \
  --role roles/iam.workloadIdentityUser

Elimina l'associazione del ruolo Amministratore Cloud Storage per l'account di servizio Google:

gcloud projects remove-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member "serviceAccount:SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com" \
  --role roles/storage.admin

Elimina il account di servizio Google che hai creato per Config Connector:

gcloud iam service-accounts delete --quiet \
  SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com

Passaggi successivi

Scopri come eseguire la convalida di Policy Controller nell'ambito di una pipeline di integrazione continua in Cloud Build.

Crea risorse Google Cloud conformi ai criteri Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Crea un cluster GKE

Configura Config Connector

Installa Policy Controller

Crea una risorsa Google Cloud utilizzando Config Connector

Crea un criterio

Verifica le norme

Vincoli di controllo

Convalidare le risorse durante lo sviluppo

Convalida le risorse create al di fuori di Config Connector

Risoluzione dei problemi

Esegui la pulizia

Elimina il progetto

Elimina le risorse

Passaggi successivi

Crea risorse Google Cloud conformi ai criteri