Crea recursos de Google Cloud que cumplan con las políticas

En este instructivo, se muestra cómo los administradores de la plataforma pueden usar las políticas del controlador de políticas para administrar la creación de recursos de Google Cloud mediante Config Connector.

En las instrucciones de este instructivo, se supone que tienes conocimientos básicos de Kubernetes o Google Kubernetes Engine (GKE). En el instructivo, defines una política que restringe las ubicaciones permitidas para los depósitos de Cloud Storage.

Realiza verificaciones del controlador de políticas, auditorías, y aplica el cumplimiento de tus recursos de clúster de Kubernetes con políticas relacionadas con las reglas empresariales, de seguridad o la normativa. El controlador de políticas se compila a partir del proyecto de código abierto Gatekeeper.

Config Connector crea y administra el ciclo de vida de los recursos de Google Cloud; para ello, los describe como recursos personalizados de Kubernetes. Para crear un recurso de Google Cloud, debes crear un recurso de Kubernetes en un espacio de nombres que administra Config Connector. En el siguiente ejemplo, se muestra cómo describir un depósito de Cloud Storage con Config Connector:

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

Si administras tus recursos de Google Cloud con Config Connector, puedes aplicar políticas del controlador de políticas a esos recursos a medida que los creas en el clúster de la edición Enterprise de Google Kubernetes Engine (GKE). Estas políticas te permiten evitar o informar acciones que creen o modifiquen recursos de formas que infrinjan tus políticas. Por ejemplo, puedes aplicar una política que restrinja las ubicaciones de los depósitos de Cloud Storage.

Este enfoque, basado en el modelo de recursos de Kubernetes (KRM), te permite usar un conjunto coherente de herramientas y flujos de trabajo para administrar tanto recursos de Kubernetes como de Google Cloud. En este instructivo, se muestra cómo realizar las siguientes tareas:

Definir políticas que rijan tus recursos de Google Cloud
Implementar controles que impidan que los desarrolladores y administradores creen recursos de Google Cloud que infrinjan tus políticas
Implementa controles que auditan tus recursos existentes de Google Cloud en relación con tus políticas, incluso si creaste esos recursos fuera de Config Connector.
Proporciona comentarios rápidos a los desarrolladores y administradores a medida que crean y actualizan las definiciones de recursos.
Validar las definiciones de recursos de Google Cloud según tus políticas antes de intentar aplicar las definiciones a un clúster de Kubernetes.

Objetivos

Crea un clúster de la edición Enterprise de Google Kubernetes Engine (GKE) que incluya el complemento de Config Connector.
Instalar Policy Controller.
Crear una política de Gatekeeper para restringir las ubicaciones permitidas para depósitos de Cloud Storage
Verificar que la política de Gatekeeper impida la creación de depósitos de Cloud Storage en ubicaciones no permitidas
Evaluar el cumplimiento de políticas de la definición de depósito de Cloud Storage durante el desarrollo
Auditar los depósitos de Cloud Storage existentes para cumplir con las políticas

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

Ir al selector de proyectos
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
En la consola de Google Cloud, activa Cloud Shell.

Activar Cloud Shell
En Cloud Shell, configura el proyecto de Google Cloud que deseas usar para este instructivo:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud. Cuando ejecutas este comando, Cloud Shell crea una variable de entorno exportada llamada GOOGLE_CLOUD_PROJECT que contiene el ID del proyecto. Si no usas Cloud Shell, puedes crear la variable de entorno con este comando:
```
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value core/project)
```

Habilita la API de GKE:

gcloud services enable container.googleapis.com

Crea un directorio para almacenar los archivos creados en este instructivo:
```
mkdir -p ~/cnrm-gatekeeper-tutorial
```
Ve al directorio que creaste:
```
cd ~/cnrm-gatekeeper-tutorial
```

Crea un clúster de GKE

En Cloud Shell, crea un clúster de GKE con el complemento de Config Connector y Workload Identity:
```
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
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre del clúster que deseas usar para este proyecto, por ejemplo, cnrm-gatekeeper-tutorial.
- ZONE: Una zona de Compute Engine cerca de tu ubicación, por ejemplo, asia-southeast1-b.
El complemento Config Connector instala definiciones de recursos personalizadas (CRD) para los recursos de Google Cloud en tu clúster de GKE.
Opcional: Si usas un clúster privado en tu propio entorno, agrega una regla de firewall que permita que el plano de control del clúster de GKE se conecte al webhook del controlador de políticas:
```
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
```
Reemplaza lo siguiente:
- CONTROL_PLANE_CIDR: El rango de IP para tu plano de control de clúster de GKE, por ejemplo, 172.16.0.16/28
- NODE_TAG: La etiqueta que se aplica a todos los nodos de tu clúster de GKE.
Esta regla de firewall opcional es obligatoria para que el webhook del controlador de políticas funcione cuando tu clúster usa nodos privados.

Configura Config Connector

El proyecto de Google Cloud en el que instalas Config Connector se conoce como el proyecto host. Los proyectos en los que utilizas Config Connector para administrar recursos se conocen como proyectos administrados. En este instructivo, debes usar Config Connector para crear recursos de Google Cloud en el mismo proyecto que tu clúster de GKE, de modo que el proyecto host y el proyecto administrado sean el mismo proyecto.

En Cloud Shell, crea una cuenta de servicio de Google para Config Connector:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name "Config Connector Gatekeeper tutorial"
```
Reemplaza SERVICE_ACCOUNT_NAME por el nombre que deseas usar para esta cuenta de servicio, por ejemplo, cnrm-gatekeeper-tutorial. Config Connector usa esta cuenta de servicio de Google para crear recursos en tu proyecto administrado.
Otorga la función Administrador de almacenamiento a la cuenta de servicio de 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
```
En este instructivo, usarás la función Administrador de almacenamiento porque usas Config Connector para crear depósitos de Cloud Storage. En tu propio entorno, otorga las funciones necesarias para administrar los recursos de Google Cloud que deseas crear para Config Connector. Para obtener más información sobre las funciones predefinidas, consulta Comprende las funciones en la documentación de IAM.
Crea un espacio de nombres de Kubernetes para los recursos de Config Connector que creas en este instructivo:
```
kubectl create namespace NAMESPACE
```
Reemplaza NAMESPACE por el espacio de nombres de Kubernetes que deseas usar en el instructivo, por ejemplo, tutorial.
Anota el espacio de nombres a fin de especificar qué proyecto de Config Connector debe usar para crear recursos de Google Cloud (el proyecto administrado):
```
kubectl annotate namespace NAMESPACE \
    cnrm.cloud.google.com/project-id=$GOOGLE_CLOUD_PROJECT
```
Crea un recurso ConfigConnectorContext que habilite Config Connector para el espacio de nombres de Kubernetes y lo asocia con la cuenta de servicio de Google que creaste:
```
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
```
Cuando creas el recurso ConfigConnectorContext, Config Connector crea una cuenta de servicio de Kubernetes y StatefulSet en el espacio de nombres cnrm-system para administrar los recursos de Config Connector en tu espacio de nombres.
Espera al Pod del controlador de Config Connector para tu espacio de nombres:
```
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
```
Cuando el Pod esté listo, aparecerá el símbolo del sistema de Cloud Shell. Si recibes el mensaje error: no matching resources found, espera un minuto y vuelve a intentarlo.
Vincula tu cuenta de servicio de Config Connector de Kubernetes con tu cuenta de servicio de Google mediante la creación de una vinculación de política de 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
```
Esta vinculación permite que la cuenta de servicio cnrm-controller-manager-NAMESPACE de Kubernetes del espacio de nombres cnrm-system actúe como la cuenta de servicio de Google que creaste.

Instalar Controlador de políticas

Instala el Policy Controller según las instrucciones de instalación.

Usa un intervalo de auditoría de 60 segundos.

Crea un recurso de Google Cloud con Config Connector

En Cloud Shell, crea un manifiesto de Config Connector que represente un depósito de Cloud Storage en la región 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

Para crear el bucket de Cloud Storage, aplica el manifiesto:
```
kubectl apply -f tutorial-storagebucket-us-central1.yaml
```
Verifica que Config Connector haya creado el depósito de Cloud Storage:
```
gsutil ls | grep tutorial
```
El resultado es similar al siguiente:
```
gs://tutorial-us-central1-PROJECT_ID/
```
Este resultado incluye PROJECT_ID, que es el ID de tu proyecto de Google Cloud.

Si no ves este resultado, espera un minuto y vuelve a realizar el paso.

Crea una política

Una política en el controlador de políticas consta de una plantilla de restricciones y una restricción. La plantilla de restricciones contiene la lógica de políticas. La restricción especifica dónde se aplica la política y los parámetros de entrada en la lógica de la política.

En Cloud Shell, crea una plantilla de restricción que restrinja las ubicaciones de los depósitos de 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

Aplica la plantilla para crear el depósito de Cloud Storage:

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

Crea una restricción que solo permita depósitos en las regiones de Singapur y Yakarta (asia-southeast1 y asia-southeast2). La restricción se aplica al espacio de nombres que indicaste antes. Exime al depósito de Cloud Storage predeterminado para 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

Para limitar las zonas en las que pueden existir los buckets, aplica la restricción:
```
kubectl apply -f tutorial-storagebucket-location-constraint.yaml
```

Verifica la política

Crea un manifiesto que represente un depósito de Cloud Storage en una ubicación no permitida (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

Para crear el bucket de Cloud Storage, aplica el manifiesto:

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

El resultado es similar al siguiente:

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"]

Opcional: Puedes ver un registro de la decisión de rechazar la solicitud en los registros de auditoría de Cloud. Consulta los Registros de actividad del administrador del proyecto:

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'

El resultado es similar al siguiente:

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'

El campo methodName muestra la operación que se intentó, resourceName muestra el nombre completo del recurso de Config Connector y la sección status muestra que la solicitud no se realizó de forma correcta, con código de error 7 y mensaje Forbidden.

Crea un manifiesto que represente un depósito de Cloud Storage en una ubicación permitida (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

Para crear el bucket de Cloud Storage, aplica el manifiesto:
```
kubectl apply -f tutorial-storagebucket-asia-southeast1.yaml
```
El resultado es similar al siguiente:
```
storagebucket.storage.cnrm.cloud.google.com/tutorial-asia-southeast1-PROJECT_ID created
```
Este resultado incluye PROJECT_ID, que es el ID de tu proyecto de Google Cloud.
Verifica que Config Connector haya creado el depósito de Cloud Storage:
```
gsutil ls | grep tutorial
```
El resultado es similar al siguiente:
```
gs://tutorial-asia-southeast1-PROJECT_ID/
gs://tutorial-us-central1-PROJECT_ID/
```
Si no ves este resultado, espera un minuto y vuelve a realizar este paso.

Restricciones de auditoría

El controlador de auditoría del controlador de políticas evalúa de forma periódica los recursos en función de sus restricciones. El controlador detecta los incumplimientos de políticas de los recursos creados antes que la restricción y los recursos creados fuera de Config Connector.

En Cloud Shell, observa los incumplimientos de todas las restricciones que usan la plantilla de restricción GCPStorageLocationConstraintV1:
```
kubectl get gcpstoragelocationconstraintv1 -o json \
  | jq '.items[].status.violations'
```
El resultado es similar al siguiente:
```
[
  {
    "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"
  }
]
```
Verás el depósito de Cloud Storage que creaste en us-central1 antes de crear la restricción.

Nota: El atributo status.violations predeterminado muestra hasta 20 incumplimientos por restricción. Si el controlador de auditoría encuentra más de 20 incumplimientos de las restricciones, el resto no se muestra. Si te encuentras con esta limitación en tu propio entorno, crea varias restricciones. Define el alcance de cada restricción a un espacio de nombres diferente.

Valida los recursos durante el desarrollo

Durante el desarrollo y las compilaciones de integración continua, es útil validar los recursos según las restricciones antes de aplicar esos recursos a tu clúster de GKE. La validación proporciona comentarios rápidos y te permite descubrir problemas relacionados con los recursos y las restricciones de manera anticipada. En estos pasos, se muestra cómo validar recursos con kpt. La herramienta de línea de comandos kpt te permite administrar y aplicar los manifiestos de recursos de Kubernetes.

En Cloud Shell, ejecuta la función KRM gatekeeper mediante kpt:

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

Una función KRM es un programa que puede mutar o validar los recursos de Kubernetes almacenados en el sistema de archivos local como archivos YAML. La función gatekeeper de KRM valida los recursos del bucket de Cloud Storage de Config Connector con la política de Gatekeeper. La función gatekeeper de KRM se empaqueta como una imagen de contenedor que está disponible en Artifact Registry.

La función informa que los archivos de manifiesto de los depósitos de Cloud Storage de las regiones us-central1 y us-west1 infringen la restricción.

El resultado es similar al siguiente:

[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

Valida los recursos creados fuera de Config Connector

Puedes validar los recursos de Google Cloud que se crearon fuera del Config Connector mediante la exportación de los recursos. Después de exportar los recursos, utiliza cualquiera de las siguientes opciones para evaluar tus políticas de Policy Controller con los recursos exportados:

Valida los recursos con la función de KRM gatekeeper.
Importa los recursos a Config Connector.

Para exportar los recursos, usa Cloud Asset Inventory.

En Cloud Shell, habilita la API de Cloud Asset:

gcloud services enable cloudasset.googleapis.com

Borra los archivos de manifiesto del recurso de Kubernetes para los buckets de Cloud Storage en us-central1 y us-west1:
```
rm tutorial-storagebucket-us-*.yaml
```

Exporta todos los recursos de Cloud Storage en tu proyecto actual y almacena el resultado en un archivo llamado export.yaml:

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

El resultado es similar al siguiente:

Exporting resource configurations to stdout...

Export complete.

Crea una canalización de kpt mediante el encadenamiento de funciones de KRM. Esta canalización valida los recursos en el directorio actual en función de la política de ubicación del bucket de 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

Los recursos exportados no tienen un valor para el atributo namespace. Esta canalización usa una función de KRM llamada set-namespace para establecer el valor namespace de todos los recursos.

El resultado es similar al siguiente y muestra incumplimientos de los recursos que exportaste:

[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

Si tu proyecto de Google Cloud contiene buckets de Cloud Storage que creaste antes de trabajar en este instructivo y su ubicación infringe la restricción, los buckets creados anteriormente aparecerán en el resultado.

Felicitaciones. Configuraste con éxito una política que regula la ubicación permitida de los depósitos de Cloud Storage. El instructivo está completo. Ahora, puedes continuar agregando tus propias políticas para otros recursos de Google Cloud.

Soluciona problemas

Si Config Connector no crea los recursos esperados de Google Cloud, usa el siguiente comando en Cloud Shell para ver los registros del administrador del controlador de 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

Si el controlador de políticas no aplica las políticas de forma correcta, usa el siguiente comando para ver sus registros:

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

Si el controlador de políticas no informa incumplimientos en el campo status de los objetos de restricción, consulta los registros del controlador de auditoría mediante este comando:

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

Si tienes otros problemas con este instructivo, te recomendamos que revises los siguientes documentos:

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
Si el proyecto que deseas borrar está vinculado con una organización, expande la lista Organización en la columna Nombre.
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra recursos

Si deseas conservar el proyecto de Google Cloud que usaste en este instructivo, borra los recursos individuales.

En Cloud Shell, borra la restricción de ubicación del depósito de Cloud Storage:
```
kubectl delete -f tutorial-storagebucket-location-constraint.yaml
```
Agrega la anotación cnrm.cloud.google.com/force-destroy con un valor de string de true a todos los recursos storagebucket en el espacio de nombres administrado por Config Connector:
```
kubectl annotate storagebucket --all --namespace NAMESPACE \
  cnrm.cloud.google.com/force-destroy=true
```
Esta anotación es una directiva que permite a Config Connector borrar un bucket de Cloud Storage cuando borras el recurso storagebucket correspondiente del clúster de GKE, incluso si el bucket contiene objetos.
Borra los recursos de Config Connector que representan los buckets de Cloud Storage:
```
kubectl delete --namespace NAMESPACE storagebucket --all
```

Borra el clúster de GKE:

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

Borra la vinculación de políticas de Workload Identity en 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

Borra la vinculación de la función Administrador de Cloud Storage para la cuenta de servicio de 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

Borra la cuenta de servicio de Google que creaste para Config Connector:

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

¿Qué sigue?

Obtén información para informar incumplimientos de auditoría del controlador de políticas en Security Command Center.
Descubre cómo ejecutar la validación del Policy Controller como parte de una canalización de integración continua en Cloud Build.