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

En este instructivo, se muestra cómo los administradores de plataformas 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 describiéndolos 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 tu clúster de 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 puedes completar 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

Crear un clúster de GKE que incluya el complemento de Config Connector
Instala el controlador de políticas.
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
```

Crear 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 de 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
```
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 de Policy Controller funcione cuando el 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.
Espere a que el Pod del controlador de Config Connector para su 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 mensaje 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, aplique 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 a este:
```
gs://tutorial-us-central1-PROJECT_ID/
```
Este resultado incluye PROJECT_ID, que es tu ID del proyecto de Google Cloud.

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

Crear 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, aplique 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, aplique el manifiesto:

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

El resultado es similar a este:

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 para 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 a este:

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, aplique el manifiesto:
```
kubectl apply -f tutorial-storagebucket-asia-southeast1.yaml
```
El resultado es similar a este:
```
storagebucket.storage.cnrm.cloud.google.com/tutorial-asia-southeast1-PROJECT_ID created
```
Este resultado incluye PROJECT_ID, que es tu ID del proyecto de Google Cloud.
Verifica que Config Connector haya creado el depósito de Cloud Storage:
```
gsutil ls | grep tutorial
```
El resultado es similar a este:
```
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 en el controlador de políticas evalúa periódicamente 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 a este:
```
[
  {
    "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 restricción, el resto no se mostrarán. Si encuentras esta limitación en tu propio entorno, crea varias restricciones. Asigna cada restricción a un espacio de nombres diferente.

Valida 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 de KRM es un programa que puede mutar o validar 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 KRM gatekeeper 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 a este:

[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 del 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 a este:

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 los incumplimientos para 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 con anterioridad 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 los registros del administrador del controlador:

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 con 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

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

Objetivos

Costos

Antes de comenzar

Crear un clúster de GKE

Configura Config Connector

Instalar Controlador de políticas

Crea un recurso de Google Cloud con Config Connector

Crear una política

Verifica la política

Restricciones de auditoría

Valida recursos durante el desarrollo

Valida los recursos creados fuera del Config Connector

Soluciona problemas

Limpia

Borra el proyecto

Borra recursos

¿Qué sigue?